So stellen Sie eine komplexe Ethereum-App bereit, die in mehrere Verträge aufgeteilt ist

Wenn Sie eine komplexe dApp entwickeln und diese aufgrund der Bereitstellungsgasgrenze in separate Einzelverträge aufteilen müssen, was ist ein sauberer Prozess/Muster für die Bereitstellung und Verknüpfung der einzelnen Verträge miteinander?

Was ich tue, ist, einen Vertrag als "Relais" für andere zu erstellen. Dort behalten Sie alle Adressen zu anderen Verträgen bei, und wenn Sie einen neuen/geänderten Vertrag bereitstellen, ändern Sie einfach die Adresse davon im Relay. Dann rufen Sie von dort aus Funktionen zu verwandten Verträgen auf, um eine neue Adresse festzulegen.
Stellen Sie sie nacheinander bereit. Wenn Vertrag X bei der Erstellung die Adresse von Vertrag Y erfordert, stellen Sie zuerst Vertrag Y bereit und verwenden Sie seine Adresse bei der Bereitstellung von Vertrag X.
Das Problem dabei ist, dass es für andere schwieriger/umständlicher wird, zu überprüfen, ob ein bestimmter Quellcode mit einer bestimmten dApp übereinstimmt. Und wie würde man diesen Prozess schön automatisieren? Trüffelwanderungen?

Antworten (2)

Ok, also hier ist, wie ich es mache.

Relay.sol:

contract Relay {

    IOtherContract private otherContractInterface;

    modifier onlyOwner() {
      require(msg.sender == owner, "Sender is not owner");
      _;
    }

    function initialize(address _otherContractAddress) external onlyOwner {

        otherContractInterface = IOtherContract(_otherContractAddress);
    }
}

OtherContract.sol:

contract OtherContract {


  address relay;

  modifier onlyRelay() {
      require(msg.sender == relay, "Sender is not relay.");
      _;
  }

  function setRelay(address _relay) external onlyOwner {
      relay = _relay;
  }
}

Und dann rufen Sie OtherContract.setRelay(relayAddress)von Ihrem Eigentümerkonto aus an oder packen es in initializeFunktion und rufen setRelaydirekt an, nachdem die neue Vertragsadresse festgelegt wurde.
BEARBEITEN : Verwenden Sie auch Schnittstellen/abstrakte Klassen, wenn Sie auf Verträge aus anderen Verträgen zugreifen. Dadurch sparen Sie Gas und können mehr Code in einen einzigen Vertrag einfügen.

Wenn Sie einen Vertrag in einen anderen importieren, wird der Bytecode einfach am Ende angehängt. Dies führt zu sehr großen Dateien/Bytecodes, wenn Sie mehrere Verträge importieren. Was ich mache, ist, für jeden Vertrag eine Schnittstelle zu implementieren und diese dann einfach zu importieren. Dann kodiere ich die Adresse der entsprechenden Verträge fest in den Vertrag, der sie umsetzt. Dadurch wird sichergestellt, dass das Design nicht manipuliert werden kann.

zB: (Pseudocode)

mycontract1.sol
implements Imycontract2.sol
{

  Imycontract(address).callFunction()
}

wobei Imycontract2.sol nur ein Dummy mit leeren Implementierungen der Funktionen von mycontract2.sol ist

So stellen Sie eine komplexe Ethereum-App bereit, die in mehrere Verträge aufgeteilt ist
AntwortenHierDatenschutz-Bestimmungen1y, 0v