Is it possible to implement the essence of smart-contract into another one before deploying the first one?

Question

My question means for example that the primary contract stores names of secondary contracts, for example like this:

mapping (address => string) secondaryContractNames;

I know we can in the primary contract define the essence of secondary contract like this: secondaryContract contract = secondaryContract(_address); Is it possible to code something like this:

secondaryContractNames[_address] contract = secondaryContractNames[_address](_address); or:

contract(secondaryContractNames[_address]) contract = contract(secondaryContractNames[_address])(_address);

So if we store secondaryContractNames[_address] as for example secondaryContract the previous code will be transformed as secondaryContract contract = secondaryContract(_address);

I know that the code below doesn't work. It's just to explain my logic. And the question is it possible in solidity or not?

Answer 1

From your previous comment:

how to implement contract(secondary) inside another contract(primary) before deploying I've already known. But you have to know the name of secondary contract so you have to create (I mean wrire the source code) of secondary contract. The question is about situation when you don't have the source code of secondary contract yet but you need to deploy the primary one.

You do not need to know the name of the contract. As long as the ABIs match up. The only thing you need is the deployed address. Then update the 1st contract deployed with said address. I can deploy these contracts below in any order, then call setContractInstance() passing in the address of the contract I want to take action on.

Knowing which methods beforehand helps one to create the proper interface/abstract contract(s) needed. But you do not care about the contract name, as it doesn't matter.

See the example I've created here: https://gist.github.com/mswezey23/b15085cc7339bf6d06f88b056a631326

pragma solidity 0.5.6;

interface DeployInterface {
    function foo() external returns (uint256);
}

contract DeploySecond is DeployInterface {
    function foo() external returns (uint256) {
        return 2;
    }
}

contract DeployThird is DeployInterface {
    function foo() external returns (uint256) {
        return 3;
    }
}


contract deployFirst {
    DeployInterface contractInstance;

    function setContractInstance(address _contractInstance) public {
        contractInstance = DeployInterface(_contractInstance);
    }

    function execDoThing() public returns (uint256) {
        return contractInstance.foo();
    }
}

Instructions:

• Deploy in any order.
• Pass either DeployThird or DeploySecond contract address to setContractInstance
• call execDoThing
• check result
• Pass in the other contract address via setContractInstance
• call execDoThing
• check result

Example to call another contract function when not knowing the function name or parameters during compile time:

contract_address.call(bytes4(sha3("function_name(types)")),parameters_values)

This goes to show that the contract name does not matter.

Source

Answer 2

It is hard to understand the task, but here are some assumptions about it and posdible approaches:

1. if you want to deploy token contract first, and then other contracts that will use this token contract, just pass address of the token contract to the constructors of other contracts, save it in storage and use;
2. if you want your token contract to use other contracts deployed later, and you know signatures of methods token contract needs to call on other contracts (but not the implementations of these methods, that could be different in different contracts), than you need to define interface with these signatures, use it in token contract and implement it in other contracts, you will also need to implement special method(s) in token contract that you will use to tell token contract addresses of other contracts;
3. if you need you token contract to actually deploy other contracts whose bytecode is not known at the time token contract is being deployed,but becomes known later, than this is also possible via assembly language.

Let me know what case better describes your task, and i will add more details to it.