Is there a way pre-deploy a library deployed from within a smart contract before it is deployed? - deployment

Question

Sorry if the question did not make sense. Here is what I am trying to do:
I want to deploy this smart contract (LenseHub) that imports a library that requires data passed to its constructor. This is problematic because I need LenseHub to initialize the contract (a function I can call only after the contract is deployed). If I try to deploy LenseHub without pre-deploying the IERC721Enumerable it will fail obviously. If I can't figure this out I will just inherit IERC721Enumerable and initialize it via the constructor, but would really like to keep the original smart contracts integrity (for testing purposes). Any suggestions on how to do this would be greatly appreciated
Here is the relevant part of the smart contract:
import {IERC721Enumerable} from "#openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
/**
* #title LensHub
* #author Lens Protocol
*
* #notice This is the main entrypoint of the Lens Protocol. It contains governance functionality as well as
* publishing and profile interaction functionality.
*
* NOTE: The Lens Protocol is unique in that frontend operators need to track a potentially overwhelming
* number of NFT contracts and interactions at once. For that reason, we've made two quirky design decisions:
* 1. Both Follow & Collect NFTs invoke an LensHub callback on transfer with the sole purpose of emitting an event.
* 2. Almost every event in the protocol emits the current block timestamp, reducing the need to fetch it manually.
*
* OVERVIEW: The lense protocall is one of the three main solidity contracts compiled. It compiles all of its code imports code into
* one main "hub" from were you can interact with the protocall.
*
*
*/
contract LensHub is
LensNFTBase,
VersionedInitializable,
LensMultiState,
LensHubStorage,
ILensHub
{
uint256 internal constant REVISION = 1;
address internal immutable FOLLOW_NFT_IMPL;
address internal immutable COLLECT_NFT_IMPL;
/**
* #dev This modifier reverts if the caller is not the configured governance address.
*/
modifier onlyGov() {
_validateCallerIsGovernance();
_;
}
/**
* #dev The constructor sets the immutable follow & collect NFT implementations.
*
* #param followNFTImpl The follow NFT implementation address.
* #param collectNFTImpl The collect NFT implementation address.
*/
constructor(address followNFTImpl, address collectNFTImpl) {
if (followNFTImpl == address(0)) revert Errors.InitParamsInvalid();
if (collectNFTImpl == address(0)) revert Errors.InitParamsInvalid();
FOLLOW_NFT_IMPL = followNFTImpl;
COLLECT_NFT_IMPL = collectNFTImpl;
}
/// #inheritdoc ILensHub
function initialize(
string calldata name,
string calldata symbol,
address newGovernance
) external override initializer {
super._initialize(name, symbol);
_setState(DataTypes.ProtocolState.Paused);
_setGovernance(newGovernance);
}
Here is the _function that the initialize function calls:
function _initialize(string calldata name, string calldata symbol) internal {
ERC721Time.__ERC721_Init(name, symbol);
emit Events.BaseInitialized(name, symbol, block.timestamp);
}
Here is the relevent part of the library:
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)
pragma solidity ^0.8.0;
import "../IERC721.sol";
/**
* #title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* #dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Enumerable is IERC721 {
/**
* #dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* #dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
/**
* #dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
Here is the constructor of ERC721 that I am trying to pass variables to :
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}

Answer 1

First of all, don't call the IERC721Enumerable a library - it is just an interface you want to implement in your contract. In the context of solidity, a library has a bit different meaning. The question became misleading in the context of solidity.
Secondly, what you want to achieve may be done in two ways - complicated but more correct and easy but less correct:
The complicated approach requires you to use IERC721Upgradeable and properly upgrade your contact when it is needed. I don't think you need to go this far because using a proxy requires a stiff learning curve, and your use case does not require it.
The easier way is to copy the needed interface methods directly inside your contract(or some other class your contact will depend on, that will be open to the needed modifications). This way, you will be able to set your name and symbol whenever you want, and your contract will still be compliant with NFT interface. I know it looks like copying code is a bad idea, but you won't be able to change anything in your contract as soon as it is deployed(if it is not upgradable) thus, copying of the code doesn't matter in the long run.