refactor(protocol): make resolveAddress internal in EssentialContract

packages/protocol/contracts/layer1/based/TaikoInbox.sol

@@ -68,7 +68,7 @@ abstract contract TaikoInbox is EssentialContract, ITaikoInbox, ITaiko {
             BatchParams memory params = abi.decode(_params, (BatchParams));
 
             {
-                address operator = resolveAddress(LibStrings.B_INBOX_OPERATOR, true);
+                address operator = resolve(LibStrings.B_INBOX_OPERATOR, true);
                 if (operator == address(0)) {
                     require(params.proposer == address(0), CustomProposerNotAllowed());
                     params.proposer = msg.sender;
@@ -292,7 +292,7 @@ abstract contract TaikoInbox is EssentialContract, ITaikoInbox, ITaiko {
             }
         }
 
-        address verifier = resolveAddress(LibStrings.B_PROOF_VERIFIER, false);
+        address verifier = resolve(LibStrings.B_PROOF_VERIFIER, false);
         IVerifier(verifier).verifyProof(ctxs, _proof);
 
         // Emit the event
@@ -479,7 +479,7 @@ abstract contract TaikoInbox is EssentialContract, ITaikoInbox, ITaiko {
 
     /// @inheritdoc ITaikoInbox
     function bondToken() public view returns (address) {
-        return resolveAddress(LibStrings.B_BOND_TOKEN, true);
+        return resolve(LibStrings.B_BOND_TOKEN, true);
     }
 
     /// @inheritdoc ITaikoInbox
@@ -664,7 +664,7 @@ abstract contract TaikoInbox is EssentialContract, ITaikoInbox, ITaiko {
                     emit Stats1Updated(stats1);
 
                     // Ask signal service to write cross chain signal
-                    ISignalService(resolveAddress(LibStrings.B_SIGNAL_SERVICE, false)).syncChainData(
+                    ISignalService(resolve(LibStrings.B_SIGNAL_SERVICE, false)).syncChainData(
                         _config.chainId, LibStrings.H_STATE_ROOT, synced.blockId, synced.stateRoot
                     );
                 }
@@ -772,7 +772,7 @@ abstract contract TaikoInbox is EssentialContract, ITaikoInbox, ITaiko {
             require(_params.signalSlots.length <= _maxSignalsToReceive, TooManySignals());
 
             ISignalService signalService =
-                ISignalService(resolveAddress(LibStrings.B_SIGNAL_SERVICE, false));
+                ISignalService(resolve(LibStrings.B_SIGNAL_SERVICE, false));
 
             for (uint256 i; i < _params.signalSlots.length; ++i) {
                 require(signalService.isSignalSent(_params.signalSlots[i]), SignalNotSent());

packages/protocol/contracts/layer1/preconf/impl/PreconfRouter.sol

@@ -28,13 +28,12 @@ contract PreconfRouter is EssentialContract, IPreconfRouter {
         returns (ITaikoInbox.BatchMetadata memory meta_)
     {
         // Sender must be the selected operator for the epoch
-        address selectedOperator = IPreconfWhitelist(
-            resolveAddress(LibStrings.B_PRECONF_WHITELIST, false)
-        ).getOperatorForEpoch();
+        address selectedOperator =
+            IPreconfWhitelist(resolve(LibStrings.B_PRECONF_WHITELIST, false)).getOperatorForEpoch();
         require(msg.sender == selectedOperator, NotTheOperator());
 
         // Call the proposeBatch function on the TaikoInbox
-        address taikoInbox = resolveAddress(LibStrings.B_TAIKO, false);
+        address taikoInbox = resolve(LibStrings.B_TAIKO, false);
         (, meta_) = ITaikoInbox(taikoInbox).proposeBatch(_batchParams, _batchTxList);
 
         // Verify that the sender had set itself as the proposer

packages/protocol/contracts/layer1/provers/ProverSetBase.sol

@@ -122,10 +122,10 @@ abstract contract ProverSetBase is EssentialContract, IERC1271 {
     }
 
     function inbox() internal view virtual returns (address) {
-        return resolveAddress(LibStrings.B_TAIKO, false);
+        return resolve(LibStrings.B_TAIKO, false);
     }
 
     function bondToken() internal view virtual returns (address) {
-        return resolveAddress(LibStrings.B_BOND_TOKEN, true);
+        return resolve(LibStrings.B_BOND_TOKEN, true);
     }
 }

packages/protocol/contracts/layer1/team/TokenUnlock.sol

@@ -104,21 +104,20 @@ contract TokenUnlock is EssentialContract {
         amountVested += _amount;
         emit TokenVested(_amount);
 
-        IERC20(resolveAddress(LibStrings.B_TAIKO_TOKEN, false)).safeTransferFrom(
+        IERC20(resolve(LibStrings.B_TAIKO_TOKEN, false)).safeTransferFrom(
             msg.sender, address(this), _amount
         );
     }
 
     /// @notice Create a new prover set.
     function createProverSet() external onlyRecipient returns (address proverSet_) {
         require(
-            resolveAddress(LibStrings.B_BOND_TOKEN, false)
-                == resolveAddress(LibStrings.B_TAIKO_TOKEN, false),
+            resolve(LibStrings.B_BOND_TOKEN, false) == resolve(LibStrings.B_TAIKO_TOKEN, false),
             TAIKO_TOKEN_NOT_USED_AS_BOND_TOKEN()
         );
 
         bytes memory data = abi.encodeCall(ProverSetBase.init, (owner(), address(this)));
-        proverSet_ = address(new ERC1967Proxy(resolveAddress(LibStrings.B_PROVER_SET, false), data));
+        proverSet_ = address(new ERC1967Proxy(resolve(LibStrings.B_PROVER_SET, false), data));
 
         isProverSet[proverSet_] = true;
         emit ProverSetCreated(proverSet_);
@@ -135,7 +134,7 @@ contract TokenUnlock is EssentialContract {
         if (!isProverSet[_proverSet]) revert NOT_PROVER_SET();
 
         emit DepositToProverSet(_proverSet, _amount);
-        IERC20(resolveAddress(LibStrings.B_TAIKO_TOKEN, false)).safeTransfer(_proverSet, _amount);
+        IERC20(resolve(LibStrings.B_TAIKO_TOKEN, false)).safeTransfer(_proverSet, _amount);
     }
 
     /// @notice Withdraws tokens by the recipient.
@@ -153,14 +152,14 @@ contract TokenUnlock is EssentialContract {
     {
         if (_amount > amountWithdrawable()) revert NOT_WITHDRAWABLE();
         emit TokenWithdrawn(_to, _amount);
-        IERC20(resolveAddress(LibStrings.B_TAIKO_TOKEN, false)).safeTransfer(_to, _amount);
+        IERC20(resolve(LibStrings.B_TAIKO_TOKEN, false)).safeTransfer(_to, _amount);
     }
 
     /// @notice Withdraws all tokens to the recipient address.
     function withdraw() external nonReentrant {
         uint256 amount = amountWithdrawable();
         emit TokenWithdrawn(recipient, amount);
-        IERC20(resolveAddress(LibStrings.B_TAIKO_TOKEN, false)).safeTransfer(recipient, amount);
+        IERC20(resolve(LibStrings.B_TAIKO_TOKEN, false)).safeTransfer(recipient, amount);
     }
 
     function changeRecipient(address _newRecipient) external onlyRecipientOrOwner {
@@ -175,13 +174,13 @@ contract TokenUnlock is EssentialContract {
     /// @notice Delegates token voting right to a delegatee.
     /// @param _delegatee The delegatee to receive the voting right.
     function delegate(address _delegatee) external onlyRecipient nonReentrant {
-        ERC20VotesUpgradeable(resolveAddress(LibStrings.B_TAIKO_TOKEN, false)).delegate(_delegatee);
+        ERC20VotesUpgradeable(resolve(LibStrings.B_TAIKO_TOKEN, false)).delegate(_delegatee);
     }
 
     /// @notice Returns the amount of token withdrawable.
     /// @return The amount of token withdrawable.
     function amountWithdrawable() public view returns (uint256) {
-        IERC20 tko = IERC20(resolveAddress(LibStrings.B_TAIKO_TOKEN, false));
+        IERC20 tko = IERC20(resolve(LibStrings.B_TAIKO_TOKEN, false));
         uint256 balance = tko.balanceOf(address(this));
         uint256 locked = _getAmountLocked();
 

packages/protocol/contracts/layer1/verifiers/Risc0Verifier.sol

@@ -81,7 +81,7 @@ contract Risc0Verifier is EssentialContract, IVerifier {
         bytes32 journalDigest = sha256(abi.encodePacked(publicInputs));
 
         // call risc0 verifier contract
-        (bool success,) = resolveAddress(RISCZERO_GROTH16_VERIFIER, false).staticcall(
+        (bool success,) = resolve(RISCZERO_GROTH16_VERIFIER, false).staticcall(
             abi.encodeCall(IRiscZeroVerifier.verify, (seal, aggregationImageId, journalDigest))
         );
         require(success, RISC_ZERO_INVALID_PROOF());

packages/protocol/contracts/layer1/verifiers/SP1Verifier.sol

@@ -84,6 +84,6 @@ contract SP1Verifier is EssentialContract, IVerifier {
     }
 
     function sp1RemoteVerifier() public view virtual returns (address) {
-        return resolveAddress(SP1_REMOTE_VERIFIER, false);
+        return resolve(SP1_REMOTE_VERIFIER, false);
     }
 }

packages/protocol/contracts/layer1/verifiers/SgxVerifier.sol

@@ -125,8 +125,7 @@ contract SgxVerifier is EssentialContract, IVerifier {
         external
         returns (uint256)
     {
-        address automataDcapAttestation =
-            resolveAddress(LibStrings.B_AUTOMATA_DCAP_ATTESTATION, true);
+        address automataDcapAttestation = resolve(LibStrings.B_AUTOMATA_DCAP_ATTESTATION, true);
 
         require(automataDcapAttestation != address(0), SGX_RA_NOT_SUPPORTED());
 

packages/protocol/contracts/layer1/verifiers/SgxVerifierBase.sol

@@ -80,8 +80,7 @@ abstract contract SgxVerifierBase is EssentialContract {
         external
         returns (uint256)
     {
-        address automataDcapAttestation =
-            resolveAddress(LibStrings.B_AUTOMATA_DCAP_ATTESTATION, true);
+        address automataDcapAttestation = resolve(LibStrings.B_AUTOMATA_DCAP_ATTESTATION, true);
 
         require(automataDcapAttestation != address(0), SGX_RA_NOT_SUPPORTED());
 

packages/protocol/contracts/layer2/DelegateOwner.sol

@@ -144,7 +144,7 @@ contract DelegateOwner is EssentialContract, IMessageInvocable {
 
     function _isAdminOrRemoteOwner(address _sender) private view returns (bool) {
         if (_sender == admin) return true;
-        if (_sender != resolveAddress(LibStrings.B_BRIDGE, false)) return false;
+        if (_sender != resolve(LibStrings.B_BRIDGE, false)) return false;
 
         IBridge.Context memory ctx = IBridge(_sender).context();
         return ctx.srcChainId == remoteChainId && ctx.from == remoteOwner;

packages/protocol/contracts/layer2/based/TaikoAnchor.sol

@@ -169,9 +169,7 @@ contract TaikoAnchor is EssentialContract, IBlockHashProvider, TaikoAnchorDeprec
         _syncChainData(_anchorBlockId, _anchorStateRoot);
         _updateParentHashAndTimestamp(parentId);
 
-        ISignalService(resolveAddress(LibStrings.B_SIGNAL_SERVICE, false)).receiveSignals(
-            _signalSlots
-        );
+        ISignalService(resolve(LibStrings.B_SIGNAL_SERVICE, false)).receiveSignals(_signalSlots);
     }
 
     /// @notice Anchors the latest L1 block details to L2 for cross-layer
@@ -296,7 +294,7 @@ contract TaikoAnchor is EssentialContract, IBlockHashProvider, TaikoAnchorDeprec
 
         /// @dev Store the L1's state root as a signal to the local signal service to
         /// allow for multi-hop bridging.
-        ISignalService(resolveAddress(LibStrings.B_SIGNAL_SERVICE, false)).syncChainData(
+        ISignalService(resolve(LibStrings.B_SIGNAL_SERVICE, false)).syncChainData(
             l1ChainId, LibStrings.H_STATE_ROOT, _anchorBlockId, _anchorStateRoot
         );
 

packages/protocol/contracts/shared/bridge/Bridge.sol

@@ -161,7 +161,7 @@ contract Bridge is EssentialContract, IBridge {
         msgHash_ = hashMessage(message_);
 
         emit MessageSent(msgHash_, message_);
-        ISignalService(resolveAddress(LibStrings.B_SIGNAL_SERVICE, false)).sendSignal(msgHash_);
+        ISignalService(resolve(LibStrings.B_SIGNAL_SERVICE, false)).sendSignal(msgHash_);
     }
 
     /// @inheritdoc IBridge
@@ -178,7 +178,7 @@ contract Bridge is EssentialContract, IBridge {
         bytes32 msgHash = hashMessage(_message);
         _checkStatus(msgHash, Status.NEW);
 
-        address signalService = resolveAddress(LibStrings.B_SIGNAL_SERVICE, false);
+        address signalService = resolve(LibStrings.B_SIGNAL_SERVICE, false);
 
         if (!ISignalService(signalService).isSignalSent(address(this), msgHash)) {
             revert B_MESSAGE_NOT_SENT();
@@ -246,7 +246,7 @@ contract Bridge is EssentialContract, IBridge {
         bytes32 msgHash = hashMessage(_message);
         _checkStatus(msgHash, Status.NEW);
 
-        address signalService = resolveAddress(LibStrings.B_SIGNAL_SERVICE, false);
+        address signalService = resolve(LibStrings.B_SIGNAL_SERVICE, false);
 
         stats.proofSize = uint32(_proof.length);
         stats.numCacheOps =
@@ -329,9 +329,7 @@ contract Bridge is EssentialContract, IBridge {
         if (!_consumeEtherQuota(_message.value)) revert B_OUT_OF_ETH_QUOTA();
 
         bool succeeded;
-        if (
-            _unableToInvokeMessageCall(_message, resolveAddress(LibStrings.B_SIGNAL_SERVICE, false))
-        ) {
+        if (_unableToInvokeMessageCall(_message, resolve(LibStrings.B_SIGNAL_SERVICE, false))) {
             succeeded = _message.destOwner.sendEther(_message.value, _SEND_ETHER_GAS_LIMIT, "");
         } else {
             if ((_message.gasLimit == 0 || _isLastAttempt) && msg.sender != _message.destOwner) {
@@ -347,7 +345,7 @@ contract Bridge is EssentialContract, IBridge {
         } else if (_isLastAttempt) {
             _updateMessageStatus(msgHash, Status.FAILED);
 
-            ISignalService(resolveAddress(LibStrings.B_SIGNAL_SERVICE, false)).sendSignal(
+            ISignalService(resolve(LibStrings.B_SIGNAL_SERVICE, false)).sendSignal(
                 signalForFailedMessage(msgHash)
             );
         } else {
@@ -369,15 +367,15 @@ contract Bridge is EssentialContract, IBridge {
         _checkStatus(msgHash, Status.RETRIABLE);
 
         _updateMessageStatus(msgHash, Status.FAILED);
-        ISignalService(resolveAddress(LibStrings.B_SIGNAL_SERVICE, false)).sendSignal(
+        ISignalService(resolve(LibStrings.B_SIGNAL_SERVICE, false)).sendSignal(
             signalForFailedMessage(msgHash)
         );
     }
 
     /// @inheritdoc IBridge
     function isMessageSent(Message calldata _message) external view returns (bool) {
         if (_message.srcChainId != block.chainid) return false;
-        return ISignalService(resolveAddress(LibStrings.B_SIGNAL_SERVICE, false)).isSignalSent({
+        return ISignalService(resolve(LibStrings.B_SIGNAL_SERVICE, false)).isSignalSent({
             _app: address(this),
             _signal: hashMessage(_message)
         });
@@ -399,7 +397,7 @@ contract Bridge is EssentialContract, IBridge {
         if (_message.srcChainId != block.chainid) return false;
 
         return _isSignalReceived(
-            resolveAddress(LibStrings.B_SIGNAL_SERVICE, false),
+            resolve(LibStrings.B_SIGNAL_SERVICE, false),
             signalForFailedMessage(hashMessage(_message)),
             _message.destChainId,
             _proof
@@ -421,7 +419,7 @@ contract Bridge is EssentialContract, IBridge {
     {
         if (_message.destChainId != block.chainid) return false;
         return _isSignalReceived(
-            resolveAddress(LibStrings.B_SIGNAL_SERVICE, false),
+            resolve(LibStrings.B_SIGNAL_SERVICE, false),
             hashMessage(_message),
             _message.srcChainId,
             _proof
@@ -437,7 +435,7 @@ contract Bridge is EssentialContract, IBridge {
         view
         returns (bool enabled_, address destBridge_)
     {
-        destBridge_ = resolveAddress(_chainId, LibStrings.B_BRIDGE, true);
+        destBridge_ = resolve(_chainId, LibStrings.B_BRIDGE, true);
         enabled_ = destBridge_ != address(0);
     }
 
@@ -474,10 +472,10 @@ contract Bridge is EssentialContract, IBridge {
     /// only allow watchdog to pause the bridge, but does not allow it to unpause the bridge.
     function _authorizePause(address addr, bool toPause) internal view override {
         // Owner and chain watchdog can pause/unpause the bridge.
-        if (addr == owner() || addr == resolveAddress(LibStrings.B_CHAIN_WATCHDOG, true)) return;
+        if (addr == owner() || addr == resolve(LibStrings.B_CHAIN_WATCHDOG, true)) return;
 
         // bridge_watchdog can pause the bridge, but cannot unpause it.
-        if (toPause && addr == resolveAddress(LibStrings.B_BRIDGE_WATCHDOG, true)) return;
+        if (toPause && addr == resolve(LibStrings.B_BRIDGE_WATCHDOG, true)) return;
 
         revert ACCESS_DENIED();
     }
@@ -558,7 +556,7 @@ contract Bridge is EssentialContract, IBridge {
         returns (uint32 numCacheOps_)
     {
         try ISignalService(_signalService).proveSignalReceived(
-            _chainId, resolveAddress(_chainId, LibStrings.B_BRIDGE, false), _signal, _proof
+            _chainId, resolve(_chainId, LibStrings.B_BRIDGE, false), _signal, _proof
         ) returns (uint256 numCacheOps) {
             numCacheOps_ = uint32(numCacheOps);
         } catch {
@@ -571,7 +569,7 @@ contract Bridge is EssentialContract, IBridge {
     /// @return true if quota manager has unlimited quota for Ether or the given amount of Ether is
     /// consumed already.
     function _consumeEtherQuota(uint256 _amount) private returns (bool) {
-        address quotaManager = resolveAddress(LibStrings.B_QUOTA_MANAGER, true);
+        address quotaManager = resolve(LibStrings.B_QUOTA_MANAGER, true);
         if (quotaManager == address(0)) return true;
 
         try IQuotaManager(quotaManager).consumeQuota(address(0), _amount) {
@@ -605,7 +603,7 @@ contract Bridge is EssentialContract, IBridge {
         returns (bool)
     {
         try ISignalService(_signalService).verifySignalReceived(
-            _chainId, resolveAddress(_chainId, LibStrings.B_BRIDGE, false), _signal, _proof
+            _chainId, resolve(_chainId, LibStrings.B_BRIDGE, false), _signal, _proof
         ) {
             return true;
         } catch {