Use la función modificadora para crear una jerarquía de contratos inteligentes

Tengo 3 contratos que quiero implementar. Los contratos son master, adminy customer. Entonces, el contrato maestro lo inicia una sola persona, el propietario de la cadena privada (basado en geth). El admincontrato proporciona acceso a ciertas direcciones. Estas admininstancias son creadas por master. Estoy usando un modifierpara asegurar esto. customerSolo se puede interactuar con el contrato mediante el contrato adminy master.

Los he asignado addressesa cuentas (con nombre de usuario y contraseña) almacenadas en mi archivo Redis db. El fragmento de mi estructura de contrato está a continuación:

Master Contract

contract MasterContract{
    bool public state = false;
    address public masterAddress;
    bool permCheck;


    // ACL
    // Subject(Role) - Object/Subject - permission - On/Off
    mapping (uint => mapping(uint => perm)) public acl;

    // Init Function
    function masterContractInit(string name,string detail){
      if(msg.sender!="0x0"){
        throw;
      }else{
        masterAddress = msg.sender;
      }
    }

    modifier onlyMasterAccess{
      if (msg.sender == masterAddress) _
      else throw;
    }
}

El contrato de administrador

contract AdminContract{
  bool state=false;
  struct Admin{
      bool status;
      string name;
  }
  mapping (address => admin ) public admins;

  // How to reference this masterAddress?
  modifier checkMasterAndAdminAccess{
    if (msg.sender == masterAddress || admins[msg.sender].status) _
    else throw;
  }

  function initAdminContract() onlyMasterAccess{    
    state = true;
  }

  function addAdmin(address addr, string name) onlyMasterAccess{
    admins[addr]=Admin(true, name);
  }

  function revokeAdmin(address addr) onlyMasterAccess{
    if(addr!="0x0"){
      throw;
    }else{
      admins[addr].status = false;
    }
  }
}

contrato de cliente

contract Customer{
  bool public state = false;

  function initCustomerContract() onlyMasterAccess{    
    state = true;
  }

  function foo() checkMasterAndAdminAccess{
    // Do something here
    // only admin or master can call this function
  }

  function bar(){
    // Do something, but allow others to modify this
  }   
}

Ahora necesito comprender mejor cómo combinar estos contratos y hacer referencia a la dirección maestra y de administrador en el contrato del cliente para usar el modificador checkMasterAndAdminAccess. Idealmente, al compilar en ABI y usarlo en mi Nodejsaplicación, me gustaría colocar estos contratos en archivos separados, ya que se volverán masivos.

¿Es esta una práctica recomendada?

Solo habrá una instancia de master contractcontrolado por una sola persona (por lo que solo una dirección tendrá acceso a ella). Los otros contratos pueden instanciarse más de una vez.

¿Puedo obtener alguna orientación sobre cómo lograr lo anterior?

Respuestas (1)

Si solo desea permitir que otros contratos accedan a su código, debe usar la herencia:

Customer is Admin:

Aunque esto no tiene mucho sentido para mí. Creo que su problema se trata menos de compartir la funcionalidad y más de la forma en que organiza su código. La forma más sencilla de gestionar los permisos es tener un contrato de guía telefónica que realice un seguimiento de los permisos de los usuarios. Luego haga que todas sus funciones hereden de ese contrato para que puedan usar los modificadores necesarios. Como esto:

contract PhoneBook {
    modifier onlyMasterAccess() {
        require(msg.sender == master);
        _;
    }
}


contract Customer is PhoneBook{
    function initCustomerContract() onlyMasterAccess {    
        state = true;
  }
}
Use la función modificadora para crear una jerarquía de contratos inteligentes
RespuestasAquíPolítica de privacidad1y, 0v