Skip to content

LinealToken

⏱ 1 min de lectura

Variante del multisig para el módulo de banks: lista plana de signers, compromisos y pruebas ZK Groth16 (usa Groth16Verifier como referencia, no hereda de él), nonces por tipo de acción y rotación de signers por el guardian con espera de 2 horas. Ver Mecanismo de Quórum.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.30;
import "../core/Groth16Verifier.sol";
abstract contract LinealQantum {
// 1 = Machine, 2 = Institution, 3 = Human
mapping(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 => uint256) public machineConfirmations;
mapping(bytes32 => uint256) public institutionConfirmations;
mapping(bytes32 => uint256) public humanConfirmations;
mapping(string => uint256) public actionNonce;
mapping(bytes32 => bool) public isExecuted;
mapping(address => bytes32) public quantumCommitments;
mapping(bytes32 => bool) public usedNullifiers;
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;
}
struct ZKProof {
uint[2] pA;
uint[2][2] pB;
uint[2] pC;
// Orden exacto que produce snarkJS para SecretVerifier():
// output primero, luego inputs públicos en orden de declaración del component main
// [0] nullifier ← output
// [1] commitment ← public input (declarado 1º en component main)
// [2] txHash ← public input (declarado 2º)
// [3] contractAddress ← public input (declarado 3º)
// [4] chainId ← public input (declarado 4º)
// [5] signerAddress ← public input (declarado 5º)
uint[6] pubSignals;
}
Groth16Verifier public zkVerifier;
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,
address _zkVerifier,
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");
require(_zkVerifier != address(0), "MultiSig: invalid zkVerifier");
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);
zkVerifier = Groth16Verifier(_zkVerifier);
}
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 setQuantumCommitment(bytes32 _hash) external onlyQorum {
require(_hash != bytes32(0), "LQ: invalid hash");
quantumCommitments[msg.sender] = _hash;
emit QuantumCommitmentUpdated(msg.sender, _hash);
}
// ───────────── ZK ─────────────
function confirmWithZK(
bytes32 txHash,
string memory actionType,
ZKProof memory proof,
bool requireHumans
) internal returns (bool) {
return _confirmWithZKFor(txHash, msg.sender, actionType, proof, requireHumans);
}
function _confirmWithZKFor(
bytes32 txHash,
address signer,
string memory actionType,
ZKProof memory proof,
bool requireHumans
) internal returns (bool) {
require(!isExecuted[txHash], "ZK: action already executed");
require(_isSigner(signer), "ZK: not a signer");
require(quantumCommitments[signer] != bytes32(0), "ZK: commitment required");
// [0] nullifier — anti-replay
bytes32 nullifier = bytes32(proof.pubSignals[0]);
require(!usedNullifiers[nullifier], "ZK: nullifier already used");
// [1] commitment
require(quantumCommitments[signer] == bytes32(proof.pubSignals[1]), "ZK: commitment mismatch");
// [2] txHash
require(txHash == bytes32(proof.pubSignals[2]), "ZK: txHash mismatch");
// [3] contractAddress (comparado como uint256, sin truncar)
require(uint256(uint160(address(this))) == proof.pubSignals[3], "ZK: contract mismatch");
// [4] chainId
require(block.chainid == proof.pubSignals[4], "ZK: chainId mismatch");
// [5] signerAddress
require(uint256(uint160(signer)) == proof.pubSignals[5], "ZK: signer mismatch");
require(
zkVerifier.verifyProof(proof.pA, proof.pB, proof.pC, proof.pubSignals),
"ZK: Invalid proof"
);
usedNullifiers[nullifier] = true;
return _confirmActionFor(txHash, signer, actionType, requireHumans);
}
// ───────────── Núcleo de confirmación (compartido) ─────────────
function _confirmActionFor(
bytes32 txHash,
address signer,
string memory actionType,
bool requireHumans
) internal returns (bool) {
require(!isExecuted[txHash], "LQ: already executed");
uint8 sType = signerType[signer];
require(sType != 0, "LQ: invalid signer");
require(requireHumans || sType != 3, "LQ: not a server layer");
require(!isConfirmed[txHash][signer], "LQ: already confirmed");
isConfirmed[txHash][signer] = true;
if (sType == 1) {
machineConfirmations[txHash]++;
} else if (sType == 2) {
institutionConfirmations[txHash]++;
} else {
humanConfirmations[txHash]++;
}
if (confirmationCount[txHash] == 0) {
emit ActionProposed(txHash, signer, actionType);
}
confirmationCount[txHash]++;
emit ActionConfirmed(txHash, signer);
if (
machineConfirmations[txHash] >= requiredMachines &&
institutionConfirmations[txHash] >= requiredInstitutions &&
(!requireHumans || humanConfirmations[txHash] >= requiredHumans)
) {
isExecuted[txHash] = true;
actionNonce[actionType]++;
emit ActionExecuted(txHash);
return true;
}
return false;
}
function confirmServers(bytes32 txHash, string memory actionType) internal returns (bool) {
return _confirmActionFor(txHash, msg.sender, actionType, false);
}
function confirm(bytes32 txHash, string memory actionType) internal returns (bool) {
return _confirmActionFor(txHash, msg.sender, actionType, true);
}
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");
}
}
}