@pendle/core-v2 5.10.2 → 5.11.1-alpha

package/contracts/limit/LimitRouterBase.sol

@@ -5,7 +5,7 @@ pragma solidity ^0.8.17;
 import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
 import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
 import "../interfaces/IPLimitRouter.sol";
-import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/TokenHelper.sol";
 import "../interfaces/IStandardizedYield.sol";
 import "./helpers/NonceManager.sol";
@@ -15,7 +15,7 @@ import {LimitMathCore as LimitMath} from "./LimitMathCore.sol";
 abstract contract LimitRouterBase is
     EIP712Upgradeable,
     IPLimitRouter,
-    BoringOwnableUpgradeable,
+    BoringOwnableUpgradeableV2,
     NonceManager,
     TokenHelper
 {
@@ -59,10 +59,11 @@ abstract contract LimitRouterBase is
     // solhint-disable-next-line no-empty-blocks
     receive() external payable {}
 
-    function initialize(address _feeRecipient) external initializer {
-        __BoringOwnable_init();
+    function initialize(address _feeRecipient, address _owner) external initializer {
+        __BoringOwnableV2_init(msg.sender);
         __EIP712_init("Pendle Limit Order Protocol", "1");
         setFeeRecipient(_feeRecipient);
+        transferOwnership(_owner, true, false);
     }
 
     function fill(

package/contracts/offchain-helpers/AddressProvider.sol

@@ -1,13 +1,13 @@
 pragma solidity ^0.8.17;
 
 import "../interfaces/IAddressProvider.sol";
-import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 
-contract AddressProvider is IAddressProvider, BoringOwnableUpgradeable {
+contract AddressProvider is IAddressProvider, BoringOwnableUpgradeableV2 {
     mapping(uint256 => address) public get;
 
-    function initialize() external initializer {
-        __BoringOwnable_init();
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
     }
 
     function set(uint256 id, address addr) external onlyOwner {

package/contracts/offchain-helpers/BalanceReader.sol

@@ -2,11 +2,11 @@
 pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../interfaces/IPMarket.sol";
 import "../interfaces/IStandardizedYield.sol";
 
-contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeable {
+contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeableV2 {
     struct UserMarketInfo {
         uint256 lpBalance;
         uint256 lpActiveBalance;
@@ -28,8 +28,8 @@ contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeable {
         _disableInitializers();
     }
 
-    function initialize() external initializer {
-        __BoringOwnable_init();
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
     }
 
     function _authorizeUpgrade(address) internal virtual override onlyOwner {}

package/contracts/offchain-helpers/BaseSplitCodeFactoryContract.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/BaseSplitCodeFactory.sol";
 
-contract BaseSplitCodeFactoryContract is BoringOwnableUpgradeable {
+contract BaseSplitCodeFactoryContract is BoringOwnableUpgradeableV2 {
     event Deployed(
         string indexed name,
         address creationCodeContractA,
@@ -14,7 +14,7 @@ contract BaseSplitCodeFactoryContract is BoringOwnableUpgradeable {
     );
 
     constructor() initializer {
-        __BoringOwnable_init();
+        __BoringOwnableV2_init(msg.sender);
     }
 
     function deploy(

package/contracts/offchain-helpers/Broadcaster.sol

@@ -3,14 +3,14 @@ pragma solidity ^0.8.17;
 
 import "../interfaces/IPVotingController.sol";
 import "../LiquidityMining/libraries/WeekMath.sol";
-import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/TokenHelper.sol";
 
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/Proxy.sol";
 
-contract Broadcaster is Initializable, BoringOwnableUpgradeable, UUPSUpgradeable, TokenHelper {
+contract Broadcaster is Initializable, BoringOwnableUpgradeableV2, UUPSUpgradeable, TokenHelper {
     IPVotingController public immutable votingController;
     uint256 public lastBroadcastedWeek;
 
@@ -18,8 +18,8 @@ contract Broadcaster is Initializable, BoringOwnableUpgradeable, UUPSUpgradeable
         votingController = IPVotingController(_votingController);
     }
 
-    function initialize() external initializer {
-        __BoringOwnable_init();
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
     }
 
     function finalizeAndBroadcast(uint64[] calldata chainIds) external {

package/contracts/offchain-helpers/EmptyUUPS.sol

@@ -3,13 +3,13 @@
 pragma solidity ^0.8.17;
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 
-contract EmptyUUPS is Initializable, UUPSUpgradeable, BoringOwnableUpgradeable {
+contract EmptyUUPS is Initializable, UUPSUpgradeable, BoringOwnableUpgradeableV2 {
     constructor() initializer {}
 
-    function initialize() external initializer {
-        __BoringOwnable_init();
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
     }
 
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}

package/contracts/offchain-helpers/ExpiredLpPtRedeemer.sol

@@ -77,4 +77,4 @@ contract ExpiredLpPtRedeemer is TokenHelper, ReentrancyGuardUpgradeable, BoringO
             _transferOut(tokens[i], msg.sender, _selfBalance(tokens[i]));
         }
     }
-}
+}

package/contracts/offchain-helpers/PendleExchangeRateOracle.sol

@@ -2,11 +2,11 @@
 pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
-import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/math/PMath.sol";
 import "../interfaces/IPExchangeRateOracle.sol";
 
-contract PendleExchangeRateOracle is BoringOwnableUpgradeable, IPExchangeRateOracle {
+contract PendleExchangeRateOracle is BoringOwnableUpgradeableV2, IPExchangeRateOracle {
     using PMath for uint256;
     using PMath for uint128;
 
@@ -36,8 +36,7 @@ contract PendleExchangeRateOracle is BoringOwnableUpgradeable, IPExchangeRateOra
     constructor(string memory _name, uint256 _maxRateDiff) initializer {
         name = _name;
         maxRateDiff = _maxRateDiff;
-
-        __BoringOwnable_init();
+        __BoringOwnableV2_init(msg.sender);
     }
 
     function getExchangeRate() external view returns (uint256) {

package/contracts/offchain-helpers/PendleLPWrapperFactory.sol

@@ -3,9 +3,9 @@ pragma solidity ^0.8.0;
 
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import "./PendleLPWrapper.sol";
-import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 
-contract PendleLPWrapperFactory is BoringOwnableUpgradeable {
+contract PendleLPWrapperFactory is BoringOwnableUpgradeableV2 {
     event LPWrapperCreated(address indexed lpToken, address indexed wrapper);
     event RewardReceiverSet(address indexed newReceiver);
 
@@ -14,7 +14,7 @@ contract PendleLPWrapperFactory is BoringOwnableUpgradeable {
     address public rewardReceiver;
 
     constructor(address _rewardReceiver) initializer {
-        __BoringOwnable_init();
+        __BoringOwnableV2_init(msg.sender);
         _setRewardReceiver(_rewardReceiver);
     }
 

package/contracts/offchain-helpers/PendleMulticallOwnerV1.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
+
+contract PendleMulticallOwnerV1 is BoringOwnableUpgradeableV2 {
+    struct Call {
+        address target;
+        uint256 value;
+        bytes callData;
+    }
+
+    constructor(address _owner) initializer {
+        __BoringOwnableV2_init(_owner);
+    }
+
+    function aggregate(Call[] calldata calls) external payable onlyOwner returns (bytes[] memory rtnData) {
+        uint256 length = calls.length;
+        rtnData = new bytes[](length);
+
+        Call calldata call;
+        for (uint256 i = 0; i < length; i++) {
+            call = calls[i];
+
+            (bool success, bytes memory resp) = call.target.call{value: call.value}(call.callData);
+            if (!success) {
+                assembly {
+                    revert(add(32, resp), mload(resp))
+                }
+            }
+
+            rtnData[i] = resp;
+        }
+    }
+
+    function withdraw() external onlyOwner {
+        payable(owner).transfer(address(this).balance);
+    }
+}

package/contracts/offchain-helpers/deploy/PendleCommonSYFactory.sol

@@ -95,7 +95,7 @@ contract PendleCommonSYFactory is BoringOwnableUpgradeableV2 {
             code.creationCodeSizeB
         );
         address proxy = address(new TransparentUpgradeableProxy(implementation, proxyAdmin, initData));
-        
+
         emit DeployedSY(id, constructorParams, proxy);
 
         IOwnable(proxy).transferOwnership(syOwner, true, false);

package/contracts/offchain-helpers/deploy/PendlePoolDeployHelperV2.sol

@@ -95,7 +95,11 @@ contract PendlePoolDeployHelperV2 is TokenHelper {
     function _createPYIfNotExist(address SY, uint32 expiry) internal returns (address PT, address YT) {
         PT = IPYieldContractFactory(yieldContractFactory).getPT(SY, uint256(expiry));
         if (PT == address(0)) {
-            (PT, YT) = IPYieldContractFactory(yieldContractFactory).createYieldContract(SY, expiry, doCacheIndexSameBlock);
+            (PT, YT) = IPYieldContractFactory(yieldContractFactory).createYieldContract(
+                SY,
+                expiry,
+                doCacheIndexSameBlock
+            );
         } else {
             YT = IPYieldContractFactory(yieldContractFactory).getYT(SY, expiry);
         }

package/contracts/oracles/PtYtLpOracle/PendlePYLpOracle.sol

@@ -4,12 +4,12 @@ pragma solidity ^0.8.17;
 import "./PendlePYOracleLib.sol";
 import "./PendleLpOracleLib.sol";
 import "../../interfaces/IPPYLpOracle.sol";
-import "../../core/libraries/BoringOwnableUpgradeable.sol";
+import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 
 // This is a pre-deployed version of PendlePtOracleLib & PendleLpOracleLib with additional utility functions.
 // Use of this contract rather than direct library integration resulting in a smaller bytecode size and simpler structure
 // but slightly higher gas usage (~ 4000 gas, 2 external calls & 1 cold code load)
-contract PendlePYLpOracle is BoringOwnableUpgradeable, IPPYLpOracle {
+contract PendlePYLpOracle is BoringOwnableUpgradeableV2, IPPYLpOracle {
     using PendlePYOracleLib for IPMarket;
     using PendleLpOracleLib for IPMarket;
 
@@ -30,8 +30,8 @@ contract PendlePYLpOracle is BoringOwnableUpgradeable, IPPYLpOracle {
         _disableInitializers();
     }
 
-    function initialize(uint16 _blockCycleNumerator) external initializer {
-        __BoringOwnable_init();
+    function initialize(uint16 _blockCycleNumerator, address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
         _setBlockCycleNumerator(_blockCycleNumerator);
     }
 

package/contracts/oracles/PtYtLpOracle/PendlePYOracleLib.sol

@@ -94,7 +94,7 @@ library PendlePYOracleLib {
 
     function getMarketLnImpliedRate(IPMarket market, uint32 duration) internal view returns (uint256) {
         if (duration == 0) {
-            (,,uint96 lnImpliedRate,,,) = IPMarket(market)._storage();
+            (, , uint96 lnImpliedRate, , , ) = IPMarket(market)._storage();
             return uint256(lnImpliedRate);
         }
 

package/deployments/80094-core.json

@@ -16,7 +16,7 @@
     },
     "baseCodeSplitter": "0x4d717868F4Bd14ac8B29Bb6361901e30Ae05e340",
     "PENDLE": "0xFf9c599D51C407A45D631c6e89cB047Efb88AeF6",
-    "governanceProxy": "0x2aD631F72fB16d91c4953A7f4260A97C2fE2f31e",
+    "governanceProxy": "0x830024529386a4a179ba6d1f31e8d49228674cd0",
     "router": "0x888888888889758F76e7103c6CbF23ABbF58F946",
     "routerFacets": {
         "ActionAddRemoveLiqV3": "0x663C21103915B68e9dA797CfdF3cAb01a037D5Ff",

package/deployments/999-core.json

@@ -0,0 +1,52 @@
+{
+    "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+    "network": {
+        "chainId": 999,
+        "treasury": "0xCbcb48e22622a3778b6F14C2f5d258Ba026b05e6",
+        "governance": "0x7877adfaded756f3248a0ebfe8ac2e2ef87b75ac",
+        "devMultisig": "0xE6F0489ED91dc27f40f9dbe8f81fccbFC16b9cb1",
+        "pendle": "0xD6Eb81136884713E843936843E286FD2a85A205A",
+        "lzEndpoint": "0x2D61DCDD36F10b22176E0433B86F74567d529aAa",
+        "wrappedNative": "0x5555555555555555555555555555555555555555",
+        "initialRewardFee": "30000000000000000",
+        "initialInterestFee": "30000000000000000",
+        "initialReserveFeePercent": "80",
+        "safeWaitTime": 15000,
+        "hardwareDeployer": "0xeea6F790F18563E91b18DF00B89d9f79b2E6761F"
+    },
+    "baseCodeSplitter": "0x8D407705b0a3d78167E979f71e009F5820f51C5E",
+    "PENDLE": "0xD6Eb81136884713E843936843E286FD2a85A205A",
+    "governanceProxy": "0x2aD631F72fB16d91c4953A7f4260A97C2fE2f31e",
+    "router": "0x888888888889758F76e7103c6CbF23ABbF58F946",
+    "routerFacets": {
+        "ActionAddRemoveLiqV3": "0x663C21103915B68e9dA797CfdF3cAb01a037D5Ff",
+        "ActionSwapPTV3": "0xd8D200d9A713A1c71cF1e7F694B14E5F1D948b15",
+        "ActionSwapYTV3": "0x4a03Ce0a268951d04E187B1CF48075eE69266e27",
+        "ActionMiscV3": "0x373Dba2055Ad40cb4815148bC47cd1DC16e92E44",
+        "ActionSimple": "0x852e59252c94716F0df19B52b36512f6C9297a96",
+        "ActionCallbackV3": "0x7b78F36aBf6cF3C6C0dd54716dFeF0607ae17846",
+        "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
+    },
+    "routerStatic": "0x6813d43782395A1F2AAb42f39aeEDE03ac655e09",
+    "pendleSwap": "0xd4F480965D2347d421F1bEC7F545682E5Ec2151D",
+    "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
+    "yieldContractFactoryV5": "0x4d717868F4Bd14ac8B29Bb6361901e30Ae05e340",
+    "marketFactoryV5": "0xa2530b4cfBF271e2B409A05C2CE520e4cB5fCc88",
+    "poolDeployHelperV2": "0x05c3087E2b30F10aFC4755D9f9776DC56F564dC3",
+    "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
+    "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
+    "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
+    "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
+    "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",
+    "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",
+    "beta": {
+        "PendleChainlinkOracleFactory": "0xAcD67f36183c8bA6b80Cfa60375510Ce17D0dd26"
+    },
+    "vePendle": "0x1fBaCedf510dAA79dfD9B41227A7ba192d5D548D",
+    "receiverEndpoint": "0xaD511b12F73c145Cf158EB92E4fa256937d952A4",
+    "gaugeController": "0x7e500c6efbb00fd3227888256e477171a1304721",
+    "vePendleAirdropDistributor": "0x42c706eab26aA8FAcFa4B3f32902bA872AaA10aC",
+    "externalRewardsDistributor": "0x1Cb446fAE25Ae19878f9f71189902e2a6A6A749c",
+    "lpWrapperFactory": "0xC33B62D73cf92970e71Ce2A6162C63D4bd7AeB26",
+    "decimalsFactory": "0x992EC6A490A4B7f256bd59E63746951D98B29Be9"
+}

package/deployments/999-offchain-helper.json

@@ -0,0 +1,7 @@
+{
+    "pendleMulticallV2": "0x1ca3352a55A3D69cA8e5aB06006e08aaF2bD09f1",
+    "implicitSwapfeeContract": "0x82Fae57b2A79D893D88488A7D8BdF2AC6bd2C463",
+    "simulateHelper": "0xc23Dd2807e51dd1D317e1321CBeEb9ace98531EE",
+    "supplyCapReader": "0x251CfB4E84CefecA6c1e6a4D8a0cb9c524e7484f",
+    "balanceReader": "0x2085F50305f656f96b22ECBfe0A4f5e786Ff0438"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "5.10.2",
+  "version": "5.11.1-alpha",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",

package/typechain-types/AddressProvider.ts

@@ -0,0 +1,281 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface AddressProviderInterface extends utils.Interface {
+  contractName: "AddressProvider";
+  functions: {
+    "claimOwnership()": FunctionFragment;
+    "get(uint256)": FunctionFragment;
+    "initialize(address)": FunctionFragment;
+    "owner()": FunctionFragment;
+    "pendingOwner()": FunctionFragment;
+    "set(uint256,address)": FunctionFragment;
+    "transferOwnership(address,bool,bool)": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "claimOwnership",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "get", values: [BigNumberish]): string;
+  encodeFunctionData(functionFragment: "initialize", values: [string]): string;
+  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "pendingOwner",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "set",
+    values: [BigNumberish, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transferOwnership",
+    values: [string, boolean, boolean]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "claimOwnership",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "get", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "pendingOwner",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "set", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "transferOwnership",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "Initialized(uint8)": EventFragment;
+    "OwnershipTransferred(address,address)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+}
+
+export type InitializedEvent = TypedEvent<[number], { version: number }>;
+
+export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
+
+export type OwnershipTransferredEvent = TypedEvent<
+  [string, string],
+  { previousOwner: string; newOwner: string }
+>;
+
+export type OwnershipTransferredEventFilter =
+  TypedEventFilter<OwnershipTransferredEvent>;
+
+export interface AddressProvider extends BaseContract {
+  contractName: "AddressProvider";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: AddressProviderInterface;
+
+  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: {
+    claimOwnership(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    get(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+
+    initialize(
+      _owner: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    owner(overrides?: CallOverrides): Promise<[string]>;
+
+    pendingOwner(overrides?: CallOverrides): Promise<[string]>;
+
+    set(
+      id: BigNumberish,
+      addr: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    transferOwnership(
+      newOwner: string,
+      direct: boolean,
+      renounce: boolean,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  claimOwnership(
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  get(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+
+  initialize(
+    _owner: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  owner(overrides?: CallOverrides): Promise<string>;
+
+  pendingOwner(overrides?: CallOverrides): Promise<string>;
+
+  set(
+    id: BigNumberish,
+    addr: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  transferOwnership(
+    newOwner: string,
+    direct: boolean,
+    renounce: boolean,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    claimOwnership(overrides?: CallOverrides): Promise<void>;
+
+    get(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+
+    initialize(_owner: string, overrides?: CallOverrides): Promise<void>;
+
+    owner(overrides?: CallOverrides): Promise<string>;
+
+    pendingOwner(overrides?: CallOverrides): Promise<string>;
+
+    set(
+      id: BigNumberish,
+      addr: string,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    transferOwnership(
+      newOwner: string,
+      direct: boolean,
+      renounce: boolean,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {
+    "Initialized(uint8)"(version?: null): InitializedEventFilter;
+    Initialized(version?: null): InitializedEventFilter;
+
+    "OwnershipTransferred(address,address)"(
+      previousOwner?: string | null,
+      newOwner?: string | null
+    ): OwnershipTransferredEventFilter;
+    OwnershipTransferred(
+      previousOwner?: string | null,
+      newOwner?: string | null
+    ): OwnershipTransferredEventFilter;
+  };
+
+  estimateGas: {
+    claimOwnership(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    get(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+
+    initialize(
+      _owner: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    owner(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pendingOwner(overrides?: CallOverrides): Promise<BigNumber>;
+
+    set(
+      id: BigNumberish,
+      addr: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    transferOwnership(
+      newOwner: string,
+      direct: boolean,
+      renounce: boolean,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    claimOwnership(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    get(
+      arg0: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    initialize(
+      _owner: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pendingOwner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    set(
+      id: BigNumberish,
+      addr: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    transferOwnership(
+      newOwner: string,
+      direct: boolean,
+      renounce: boolean,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}