La pregunta es, ¿cómo puedo implementar una función en el contrato inteligente que pueda realizar un seguimiento de todas las partes interesadas? La razón por la que pregunto es porque me gustaría que el contrato pague dividendos. Hasta ahora, la única forma que se me ocurre es almacenar las direcciones de cada parte interesada en una matriz dinámica. Lo único que me preocupa, y he estado luchando por encontrar una respuesta a esta pregunta, es: ¿cuál es el tamaño o la capacidad máxima de una matriz dinámica en Solidity? Además, ¿estoy perdiendo el tiempo con este enfoque? ¿Hay una mejor manera de resolver este problema?
Otra forma de almacenar direcciones, en este caso, sería mantener un recuento de direcciones y guardar direcciones en una asignación. Cada vez que agregue una nueva dirección en el mapeo, aumente también el conteo.
mapping (unit => address) AddressStorage;
Y cada vez que desee enviar tokens a estas direcciones, simplemente itere hasta el atributo de conteo y acceda a una dirección como esta:
AddressStorage[count]
Esta no es una solución optimizada, pero ciertamente es otra forma de almacenar en lugar de almacenar en la matriz dinámica.
Espero que esto ayude.
Seguimiento de las partes interesadas
Un enfoque sería aprovechar una dApp para escanear los bloques en la cadena de bloques en busca de los eventos de transferencia que generó su token. Luego, puede acumular una lista de direcciones que tienen saldos de tokens y luego tiene una lista de titulares de tokens. No se ejecuta en la red y no le costaría nada ejecutarlo.
Si quisiera hacer esto interno al contrato, será muy costoso en la memoria. Así que la dApp es probablemente el camino a seguir.
Pago de dividendos
Si la intención es que pague dividendos en forma de tokens emitidos, puede invertir la lógica y exigir que las partes interesadas "cobren" sus dividendos emitiendo una transacción con un método que usted expone.
Puede implementar esto de manera que mantenga un mapeo del propietario => mapeo de saldos. En el segundo mapeo, podría acumular las cantidades que han recibido o no dividendos. Además, al usar un identificador incremental para cada vez que otorga un dividendo, podrían cobrar los dividendos anteriores al mismo tiempo.
Si usa este método, podría proteger cualquier método basado en transacciones para ese propietario e incluso podría actualizar automáticamente el pago de dividendos de los titulares de la cuenta en ese momento.
Aquí hay un ejemplo que implementa los conceptos básicos de este enfoque:
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