Die Frage ist, wie kann ich ein Feature im Smart Contract implementieren, das alle Beteiligten im Auge behalten kann. Der Grund, warum ich frage, ist, dass ich möchte, dass der Vertrag Dividenden auszahlt. Bisher kann ich mir nur vorstellen, die Adressen jedes Stakeholders in einem dynamischen Array zu speichern. Das einzige, was mich beunruhigt, und ich habe Mühe, eine Antwort auf diese Frage zu finden, ist: Was ist die maximale Größe oder Kapazität eines dynamischen Arrays in Solidity? Verschwende ich auch meine Zeit mit diesem Ansatz? Gibt es einen besseren Weg, dieses Problem zu lösen?
Eine andere Art, Adressen zu speichern, wäre in diesem Fall, eine Zählung von Adressen zu führen und Adressen in einer Zuordnung zu speichern. Jedes Mal, wenn Sie dem Mapping eine neue Adresse hinzufügen, erhöhen Sie auch die Anzahl.
mapping (unit => address) AddressStorage;
Und wann immer Sie Token an diese Adresse senden möchten, iterieren Sie einfach bis zum Attribut count und greifen Sie wie folgt auf die Adresse zu -
AddressStorage[count]
Dies ist keine optimierte Lösung, aber sicherlich eine andere Art des Speicherns als das Speichern im dynamischen Array.
Hoffe das hilft.
Behalten Sie den Überblick über die Beteiligten
Ein Ansatz wäre, eine dApp zu nutzen, um die Blöcke in der Blockchain nach den von Ihrem Token generierten Übertragungsereignissen zu durchsuchen. Sie könnten dann eine Liste von Adressen sammeln, die Token-Guthaben haben, und dann haben Sie eine Liste von Token-Inhabern. Es wird nicht im Netzwerk ausgeführt und würde Sie kein Benzin kosten, um es auszuführen.
Wenn Sie dies vertragsintern tun möchten, wird dies sehr speicherintensiv. Die dApp ist also wahrscheinlich der richtige Weg.
Dividenden zahlen
Wenn die Absicht besteht, Dividenden in Form der ausgegebenen Token zu zahlen, könnten Sie die Logik umkehren und verlangen, dass die Beteiligten ihre Dividenden „einsammeln“, indem sie eine Transaktion an eine Methode ausgeben, die Sie offenlegen.
Sie könnten dies so implementieren, dass Sie eine Zuordnung von Eigentümern => Zuordnung von Salden beibehalten. In der zweiten Zuordnung könnten Sie die Beträge, die Dividenden erhalten/nicht erhalten haben, in einen Bucket einteilen. Verwenden Sie auch eine inkrementelle Kennung für jedes Mal, wenn Sie eine Dividende auszahlen, dann könnten sie gleichzeitig die vergangenen Dividenden einziehen.
Wenn Sie diese Methode verwenden, können Sie jede transaktionsbasierte Methode für diesen Eigentümer schützen und sogar die Dividendenauszahlung des Kontoinhabers zu diesem Zeitpunkt automatisch aktualisieren.
Hier ist ein Beispiel, das die Grundlagen dieses Ansatzes implementiert:
pragma solidity ^0.4.0;
contract DividendToken {
address contractOwner = msg.sender;
uint[] dividendsAwarded;
mapping(address => mapping(uint => uint)) balances;
function awardDividends(uint _percent) {
require(msg.sender==contractOwner);
dividendsAwarded.push(_percent);
}
function balanceOf(address _stakeHolder) constant returns(uint balance) {
mapping(uint => uint) stakeHolderBalances = balances[_stakeHolder];
uint balanceToApplyDividend;
uint dividendAward;
for(uint i=0;i<dividendsAwarded.length;i++) {
balanceToApplyDividend += stakeHolderBalances[i];
dividendAward = (balanceToApplyDividend * dividendsAwarded[i]) / 100;
balance += balanceToApplyDividend + dividendAward;
}
balance += stakeHolderBalances[dividendsAwarded.length];
}
function transfer(address _to, uint _amount) returns(bool success) {
collectDividends(msg.sender);
balances[msg.sender][dividendsAwarded.length] -= _amount;
balances[_to][dividendsAwarded.length] += _amount;
return true;
}
function collectDividends(address _stakeHolder) {
mapping(uint => uint) stakeHolderBalances = balances[_stakeHolder];
uint newBalance = balanceOf(_stakeHolder);
for(uint i=0;i<dividendsAwarded.length;i++) {
delete stakeHolderBalances[i];
}
stakeHolderBalances[dividendsAwarded.length] = newBalance;
}
function giveTokens(uint _amount) {
balances[msg.sender][dividendsAwarded.length] = _amount;
}
}
Sanchit