Triple Consenso Lineal (3CL)
⏱ 4 min de lectura
El Triple Consenso Lineal (3CL) es el mecanismo de gobernanza del protocolo Lineal Qorum Finternet. Su regla base es simple:
Nadie decide solo. Ninguna operación administrativa se ejecuta hasta que tres estratos independientes alcanzan, cada uno, su mínimo de firmas.
Se llama triple porque exige la convergencia de tres poderes distintos, y lineal porque el consenso se recorre en línea a través de los estratos: cada capa debe cumplir su umbral para que la operación avance y se ejecute.
El principio: separación de poderes criptográfica
Section titled “El principio: separación de poderes criptográfica”Un sistema tradicional depende de un “super-usuario” o de un único administrador. Si esa credencial se compromete, el daño es total. El 3CL elimina ese punto único de falla distribuyendo la autoridad en tres estratos que no pueden ejecutar nada por separado:
- Un firmante individual no ejecuta nada.
- Un estrato aislado no ejecuta nada.
- Solo la combinación de los estratos, cada uno con su mínimo, ejecuta.
Esto se implementa en el contrato base LinealQorum, que clasifica a cada firmante con un signerType.
Los tres estratos
Section titled “Los tres estratos”| Estrato | signerType |
Quién firma | Cantidad | Umbral del estrato |
|---|---|---|---|---|
| 1 — Máquinas | 1 |
Nodos/servidores automatizados, multi-cloud | 4 | 3/4 |
| 2 — Instituciones | 2 |
Servidores institucionales (infraestructura local) | 4 | 3/4 |
| 3 — Humanos | 3 |
Personas / directiva institucional | 3 | 3/3 |
Estrato 1 — Máquinas
Section titled “Estrato 1 — Máquinas”Servidores automatizados distribuidos en multi-cloud: DEMOS, NOMOS, KRITOS, EKKLESIA. Firman de forma automática y representan la capa de protocolo. Con 4 nodos, el umbral es 3/4 (tolerancia bizantina f = 1).
Estrato 2 — Instituciones
Section titled “Estrato 2 — Instituciones”Servidores institucionales en infraestructura local: AGORA, TECNE, ETHOS, ACHE. Representan la voluntad de la institución y ejecutan su parte del quórum. Con 4 nodos, el umbral es 3/4 (f = 1). El constructor exige mínimo 4 validadores en este estrato.
Estrato 3 — Humanos
Section titled “Estrato 3 — Humanos”Personas de la directiva institucional (3 personas). Su aprobación es manual y solo se requiere en las operaciones críticas. Umbral 3/3.
Cómo se combinan los estratos
Section titled “Cómo se combinan los estratos”El 3CL tiene dos modos de ejecución, según qué estratos se requieran:
| Modo | Función interna | Estratos que firman | Se ejecuta cuando |
|---|---|---|---|
| Servers | confirmServers (onlyServers) |
1 + 2 | máquinas ≥ requiredMachines y instituciones ≥ requiredInstitutions |
| Tripartito | confirm (onlyQorum) |
1 + 2 + 3 | Los tres estratos alcanzan su mínimo |
Umbrales del despliegue actual
Section titled “Umbrales del despliegue actual”| Modo | Umbral | Composición |
|---|---|---|
onlyServers |
6/8 | 3 máquinas + 3 instituciones |
onlyQorum |
9/11 | 3 máquinas + 3 instituciones + 3 humanos |
LinealTransaction |
18/22 | multisig plano con pruebas ZK |
flowchart TD
A["Acción administrativa"] --> B{"¿Qué modo?"}
B -->|onlyServers| M1["Estrato 1 · Máquinas\n3/4"]
B -->|onlyServers| M2["Estrato 2 · Instituciones\n3/4"]
M1 --> R1["6/8 → EJECUTA"]
M2 --> R1
B -->|onlyQorum| Q1["Estrato 1 · Máquinas\n3/4"]
B -->|onlyQorum| Q2["Estrato 2 · Instituciones\n3/4"]
B -->|onlyQorum| Q3["Estrato 3 · Humanos\n3/3"]
Q1 --> R2["9/11 → EJECUTA"]
Q2 --> R2
Q3 --> R2
Flujo de una acción
Section titled “Flujo de una acción”No hay funciones separadas de “proponer”, “confirmar” y “ejecutar”: cada firmante llama a la misma función de negocio con los mismos parámetros.
- La primera llamada abre la propuesta (
ActionProposed) y cuenta como una confirmación. - Las siguientes llamadas de otros signers suman confirmaciones (
ActionConfirmed). - La llamada que completa todos los umbrales ejecuta el cambio en esa misma transacción (
ActionExecuted).
El hash de la acción incluye el tipo, la dirección del contrato, el chainid, el hash de los parámetros y un nonce por tipo de acción:
keccak256(abi.encode( keccak256(bytes(actionType)), address(this), block.chainid, keccak256(params), actionNonce[actionType]))Cambiar un solo parámetro genera otra propuesta, y el nonce impide reutilizar una aprobación ya ejecutada.
Requisitos estructurales (constructor)
Section titled “Requisitos estructurales (constructor)”El constructor de LinealQorum impone mínimos por estrato para evitar configuraciones débiles:
- Mínimo 3 firmantes por estrato.
- Mínimo 4 validadores en el estrato de servidores institucionales.
- Exactamente 3 personas (humanos).
Recuperación de firmantes
Section titled “Recuperación de firmantes”La rotación de firmantes no depende de una entidad central: usa un umbral (recoveryQuorum) con demora obligatoria.
- Un signer propone la rotación (
proposeRecovery). - Los signers confirman (
confirmRecovery). - Con
confirmaciones ≥ recoveryQuorumy tras 2 horas (RECOVERY_DELAY),executeRecoveryreemplaza los conjuntos de firmantes y sus umbrales.
Resistencia
Section titled “Resistencia”- Bizantina: con 4 nodos por estrato de servidores, f = 1. Se tolera 1 nodo caído o malicioso; 2 comprometidos bloquean la operación (fail-safe).
- Post-cuántica:
LinealQantumañade pruebas Groth16 (SNARK) con commitments Poseidon ynullifieranti-replay, ligadas a la acción, al contrato y a la cadena.
Relación con los contratos
Section titled “Relación con los contratos”| Contrato | Rol | Estratos |
|---|---|---|
LinealQorum |
Base del 3CL | Máquinas + Instituciones + Humanos |
LinealKernel, LinealToken, LinealLiquidity, LinealRouter, LinealStorage, LinealInstitution… |
Heredan LinealQorum |
Según el modo de cada función (onlyServers / onlyQorum) |
LinealQantum (banks) |
Multisig plano + ZK | Lista única de signers |
Contrato
Section titled “Contrato”// SPDX-License-Identifier: UNLICENSEDpragma solidity ^0.8.30;
/*** @title LinealQorum* @author NeoQuor - Lineal Qorum Fundation* @notice Sistema Multi-firma tripartito para combatir la corrupción y el fraude sistémico, jake al rey.**/abstract contract LinealQorum {// 1 = Machine, 2 = Institution, 3 = Humanmapping(address => uint8) public signerType;
address[] public machines; address[] public institutions; address[] public humans;
uint256 public requiredMachines; uint256 public requiredInstitutions; uint256 public requiredHumans;
address public guardian; address public identityContract;
mapping(bytes32 => mapping(address => bool)) public isConfirmed; mapping(bytes32 => uint256) public confirmationCount; mapping(bytes32 => bool) public isExecuted;
mapping(bytes32 => uint256) public machineConfirmations; mapping(bytes32 => uint256) public institutionConfirmations; mapping(bytes32 => uint256) public humanConfirmations;
mapping(string => uint256) public actionNonce;
uint256 public recoveryQuorum; uint256 public constant RECOVERY_DELAY = 2 hours;
struct RecoveryProposal { address[] newMachines; address[] newInstitutions; address[] newHumans; uint256 newRequiredMachines; uint256 newRequiredInstitutions; uint256 newRequiredHumans; uint256 proposedAt; uint256 confirmations; bool executed; mapping(address => bool) confirmedBy; }
mapping(bytes32 => RecoveryProposal) private _recoveryProposals;
event ActionProposed(bytes32 indexed txHash, address indexed proposer, string actionType); event ActionConfirmed(bytes32 indexed txHash, address indexed signer); event ActionExecuted(bytes32 indexed txHash); event GuardianUpdated(address indexed newGuardian); event QuantumCommitmentUpdated(address indexed signer, bytes32 commitment); event RecoveryProposed(bytes32 indexed recoveryHash, address indexed proposer); event RecoveryConfirmed(bytes32 indexed recoveryHash, address indexed confirmer, uint256 confirmations); event RecoveryExecuted(bytes32 indexed recoveryHash);
modifier onlyQorum() { require(signerType[msg.sender] != 0, "LQ: not signer"); _; }
modifier onlyServers() { uint8 sType = signerType[msg.sender]; require(sType == 1 || sType == 2, "LQ: not a server layer"); _; }
modifier onlyGuardian() { require(msg.sender == guardian, "LQ: only guardian"); _; }
constructor( address[] memory _qorumServers, uint256 _requiredQorumServers, address[] memory _institutionsServers, uint256 _requiredInstitutionsServers, address[] memory _operators, uint256 _requiredOperators, uint256 _recoveryQuorum ) { require(_requiredQorumServers > 0 && _qorumServers.length >= _requiredQorumServers, "LQ: invalid machines req"); require(_requiredInstitutionsServers > 0 && _institutionsServers.length >= _requiredInstitutionsServers, "LQ: invalid inst req"); require(_recoveryQuorum > 0, "LQ: invalid recovery quorum");
requiredMachines = _requiredQorumServers; requiredInstitutions = _requiredInstitutionsServers; recoveryQuorum = _recoveryQuorum;
if (_operators.length > 0) { require(_requiredOperators > 0 && _operators.length >= _requiredOperators, "LQ: invalid humans req"); requiredHumans = _requiredOperators; }
_addSigners(_qorumServers, 1, machines); _addSigners(_institutionsServers, 2, institutions); _addSigners(_operators, 3, humans); }
function proposeRecovery( address[] memory _newMachines, uint256 _newRequiredMachines, address[] memory _newInstitutions, uint256 _newRequiredInstitutions, address[] memory _newHumans, uint256 _newRequiredHumans ) external onlyQorum returns (bytes32 recoveryHash) { require(_newRequiredMachines > 0 && _newMachines.length >= _newRequiredMachines, "LQ: invalid machines"); require(_newRequiredInstitutions > 0 && _newInstitutions.length >= _newRequiredInstitutions, "LQ: invalid inst"); require(_newRequiredHumans > 0 && _newHumans.length >= _newRequiredHumans, "LQ: invalid humans");
_validateAddresses(_newMachines); _validateAddresses(_newInstitutions); _validateAddresses(_newHumans);
recoveryHash = keccak256(abi.encode( _newMachines, _newRequiredMachines, _newInstitutions, _newRequiredInstitutions, _newHumans, _newRequiredHumans, address(this), block.chainid ));
RecoveryProposal storage proposal = _recoveryProposals[recoveryHash]; require(proposal.proposedAt == 0, "LQ: proposal exists");
proposal.newMachines = _newMachines; proposal.newInstitutions = _newInstitutions; proposal.newHumans = _newHumans; proposal.newRequiredMachines = _newRequiredMachines; proposal.newRequiredInstitutions = _newRequiredInstitutions; proposal.newRequiredHumans = _newRequiredHumans; proposal.proposedAt = block.timestamp; proposal.confirmations = 1; proposal.confirmedBy[msg.sender] = true;
emit RecoveryProposed(recoveryHash, msg.sender); emit RecoveryConfirmed(recoveryHash, msg.sender, 1); }
function confirmRecovery(bytes32 recoveryHash) external onlyQorum { RecoveryProposal storage proposal = _recoveryProposals[recoveryHash]; require(proposal.proposedAt != 0, "LQ: proposal not found"); require(!proposal.executed, "LQ: already executed"); require(!proposal.confirmedBy[msg.sender], "LQ: already confirmed");
proposal.confirmedBy[msg.sender] = true; proposal.confirmations++;
emit RecoveryConfirmed(recoveryHash, msg.sender, proposal.confirmations); }
function executeRecovery(bytes32 recoveryHash) external onlyQorum { RecoveryProposal storage proposal = _recoveryProposals[recoveryHash]; require(proposal.proposedAt != 0, "LQ: not found"); require(!proposal.executed, "LQ: already executed"); require(proposal.confirmations >= recoveryQuorum, "LQ: insufficient confirmations"); require(block.timestamp >= proposal.proposedAt + RECOVERY_DELAY, "LQ: delay not passed");
proposal.executed = true;
_clearSigners(machines); _clearSigners(institutions); _clearSigners(humans);
_addSigners(proposal.newMachines, 1, machines); _addSigners(proposal.newInstitutions, 2, institutions); _addSigners(proposal.newHumans, 3, humans);
requiredMachines = proposal.newRequiredMachines; requiredInstitutions = proposal.newRequiredInstitutions; requiredHumans = proposal.newRequiredHumans;
emit RecoveryExecuted(recoveryHash); }
function setGuardian(address _newGuardian) external virtual onlyQorum { require(_newGuardian != address(0), "LQ: invalid guardian"); guardian = _newGuardian; emit GuardianUpdated(_newGuardian); }
function confirmServers( bytes32 txHash, string memory actionType ) internal returns (bool) { require(!isExecuted[txHash], "LQ: already executed"); uint8 sType = signerType[msg.sender]; require(sType == 1 || sType == 2, "LQ: not a server layer"); require(!isConfirmed[txHash][msg.sender], "LQ: already confirmed");
isConfirmed[txHash][msg.sender] = true;
if (sType == 1) { machineConfirmations[txHash]++; } else { institutionConfirmations[txHash]++; }
if (confirmationCount[txHash] == 0) { emit ActionProposed(txHash, msg.sender, actionType); }
confirmationCount[txHash]++; emit ActionConfirmed(txHash, msg.sender);
if ( machineConfirmations[txHash] >= requiredMachines && institutionConfirmations[txHash] >= requiredInstitutions ) { isExecuted[txHash] = true; actionNonce[actionType]++; emit ActionExecuted(txHash); return true; }
return false; }
function confirm( bytes32 txHash, string memory actionType ) internal returns (bool) { require(!isExecuted[txHash], "LQ: already executed"); require(signerType[msg.sender] != 0, "LQ: invalid signer"); require(!isConfirmed[txHash][msg.sender], "LQ: already confirmed");
isConfirmed[txHash][msg.sender] = true; uint8 sType = signerType[msg.sender];
if (sType == 1) { machineConfirmations[txHash]++; } else if (sType == 2) { institutionConfirmations[txHash]++; } else if (sType == 3) { humanConfirmations[txHash]++; }
if (confirmationCount[txHash] == 0) { emit ActionProposed(txHash, msg.sender, actionType); }
confirmationCount[txHash]++; emit ActionConfirmed(txHash, msg.sender);
if ( machineConfirmations[txHash] >= requiredMachines && institutionConfirmations[txHash] >= requiredInstitutions && humanConfirmations[txHash] >= requiredHumans ) { isExecuted[txHash] = true; actionNonce[actionType]++; emit ActionExecuted(txHash); return true; }
return false; }
function _computeActionHash( string memory actionType, bytes memory params ) internal view returns (bytes32) { return keccak256(abi.encode( keccak256(bytes(actionType)), address(this), block.chainid, keccak256(params), actionNonce[actionType] )); }
function _isSigner(address account) public view returns (bool) { return signerType[account] != 0; }
function _isMachine(address account) internal view returns (bool) { return signerType[account] == 1; }
function _isInstitution(address account) internal view returns (bool) { return signerType[account] == 2; }
function _isHuman(address account) internal view returns (bool) { return signerType[account] == 3; }
function _addSigners(address[] memory accounts, uint8 typeId, address[] storage storageArray) private { for (uint256 i = 0; i < accounts.length; i++) { address acc = accounts[i]; require(acc != address(0), "LQ: zero address"); require(signerType[acc] == 0, "LQ: duplicate signer"); signerType[acc] = typeId; storageArray.push(acc); } }
function _clearSigners(address[] storage storageArray) private { for (uint256 i = 0; i < storageArray.length; i++) { signerType[storageArray[i]] = 0; } uint256 len = storageArray.length; for (uint256 i = 0; i < len; i++) { storageArray.pop(); } }
function _validateAddresses(address[] memory accounts) private pure { for (uint256 i = 0; i < accounts.length; i++) { require(accounts[i] != address(0), "LQ: zero address proposed"); } }}Documentación relacionada
Section titled “Documentación relacionada”- Protocolo de contratos:
protocol/whitepapper.md - Infraestructura y estratos de red:
protocol/infraestructure.md - Kernel (registro central):
protocol/kernel.md - Seguridad y riesgos:
technical/security.md
