Fragen Sie die öffentlichen Daten mehrerer intelligenter Verträge ab

Dies ist ein Hub & Spoke-Muster, das so angepasst ist, dass es ungefähr Ihrem Code zugeordnet werden kann. Der Hub stellt Personenverträge bereit und verfolgt sie. Sie können die ungeordnete Liste von web3 durchlaufen und bei Bedarf ein Element aus der Liste löschen. Sie können Personen- und Hub-Berechtigungen auf Personenebene hinzufügen oder entfernen. Wenn Sie möchten, können Sie zum Beispiel eine selfDestruct-Funktion in den Person-Vertrag aufnehmen und ihn zu onlyOwner (nur Hub kann ihn zerstören) oder onlyPerson für die Selbstlöschung machen. Dargestellt ohne Gewähr. Sehr wenig Tests. ;-)

pragma solidity ^0.4.6;

contract Hub {

  // two-way interable index with delete
  mapping(address => uint) personMap;
  address[] public personIndex;

  address public owner;

  function Hub() {
    owner = msg.sender;
  }

  modifier onlyOwner() {
    if(msg.sender != owner) throw;
    _;
  }

  function createPerson() 
    public
    returns(address newPerson)
  {
    Person p = new Person(msg.sender);              // whoever called this will "own" the Person contract created
    personMap[p] = personIndex.length;              // remember where it lives in the unordered list
    personIndex.push(p);                            // append to the end of the list
    return p;
  }

  function deletePerson(address person) 
    onlyOwner
    returns(bool success)
  {
    // step by step for clarity
    uint location = personMap[person];              // location on the list
    address personAddress = personIndex[location];  // should match the person
    // as one line
    if(personIndex[personMap[person]] != person) throw; // non-existent person
    // move the last item in the index to the location where the unperson was
    personIndex[personMap[person]] = personIndex[personIndex.length-1];
    // also have to update the personMap because the last item changed position in the list
    // whoever was in the last row is now in the row where we are removing a record
    personMap[personIndex[personIndex.length-1]] = personMap[person]; 
    // now the list is shorter
    personIndex.length--;
    // person is removed from the list
    return true;
  }

  // the next two functions make the unordered list of contracts iterable

  function getPersonCount() 
    public
    constant
    returns(uint count)
  {
    return personIndex.length;
  }

  function getPersonAtIndex(uint index)
    public
    constant
    returns(address person)
  {
    return personIndex[index];
  }
}

contract Person {

  // address public owner;
  address public personOwner;

  struct PersonStruct {
    bytes32 encrypted1;
    bytes32 encrypted2;
  }

  PersonStruct p;

  modifier onlyPerson {                       // add this to functions only the "person" passed in should be able to do
    if(msg.sender != personOwner) throw;
    _;
  }

  function Person(address person) {
    personOwner = person;                   // passed in by the creating Hub
    // owner = msg.sender                   // this would enable the Hub to have certain privileges if needed
  }

  function getPerson()
    onlyPerson
    constant
    returns(bytes32, bytes32)
  {
    return(p.encrypted1, p.encrypted2);
  }

  function setPerson(bytes32 part1, bytes32 part2)
    onlyPerson
    returns(bool success)
  {
    p.encrypted1 = part1;
    p.encrypted2 = part2;
    return true;
  }
}

Die Standard-Ethereum-Clients (Geth und Parity) pflegen nur einen begrenzten Satz von Indizes zum Abfragen der Blockchain. Beispielsweise können Sie eine Transaktion nach ihrem Hash suchen (mit web3 getTransaction(hash)oder RPC eth_getTransactionByHash), aber Sie können Transaktionen nicht nach Absender suchen. Dienste wie http://etherscan.io , die eine vollständigere Navigation bieten, verwenden benutzerdefinierte Clients, die zusätzliche Indizes erstellen.

Sie müssen also selbst einen Index erstellen. Sie haben jedoch die Wahl, ob Sie den Index in der Blockchain speichern oder nicht. Um ihn in der Kette zu speichern, könnten Sie den PeopleKonstruktor veranlassen, sich selbst in einem Singleton-Vertrag zu registrieren, der vorhanden ist, um Speicher für den Index bereitzustellen. Der Registrierungsvertrag könnte ein Mitgliedsfeld haben address[] people, um die Liste der Personenadressen zu speichern.

Beachten Sie jedoch, dass Solidity für echte Datenstrukturen wie veränderliche Listen nicht so praktisch ist: Sie können kein Element aus der Mitte eines Arrays entfernen und es gibt keine Möglichkeit, die Schlüssel einer Zuordnung aufzuzählen.

Wenn Sie bereit sind, den Index außerhalb der Kette zu speichern, benötigen Sie immer noch eine Möglichkeit, die Liste der Personenverträge aus der Kette abzurufen. Wenn jede People-Instanz von derselben Adresse (oder einer kleinen, bekannten Gruppe von Erstelleradressen) erstellt wird, können Sie alle People-Verträge nachträglich finden, indem Sie den gesamten Transaktionsverlauf wiedergeben. Oder Sie könnten dem People-Konstruktor eine Ereignisprotokollanweisung hinzufügen, und dann könnte Ihr Off-Chain-Code nach Protokollereignissen dieses Typs suchen. Aber keine dieser Techniken gibt Ihnen einen Index, der vom On-Chain-Vertragscode verwendet werden kann.