Skip to content

Lineal Transaction

⏱ 1 min de lectura

Transacciones institucionales con doble multisig (hereda LinealQantum del módulo banks):

Signer CREA la tx y define 3 autorizadores administrativos → 3/3 autorizadores firman
→ el quórum estático de signers confirma → EJECUCIÓN en el banco
Elemento Descripción
createTransaction Solo signers. Exige referenceHash único y no reutilizable. Los 3 autorizadores no pueden ser signers estáticos ni repetirse (separación de deberes). Expira a los 3 días
authorizeTransaction Un signer estático confirma el quórum estático, o un autorizador humano firma su parte
aggregateConsensus Procesa en una transacción 3 firmas humanas (ECDSA sobre txId) y 6 pruebas ZK de servidores
cancelTransaction Cancelación con quórum
setBankAddress Solo el guardian. Define el banco que ejecuta la liberación

Campos de QorumTransaction: to, amount, referenceHash, createdBy, timestamp, expiresAt, executed, cancelled, fromAccount, tokenAddress, meta (recipientName, motivo, documento, mensaje, tipo), administrativeAuthorizers[3], adminSignatures y staticMultiSigCompleted.

Cuando ambos quórums están completos, la transacción se marca ejecutada, se agrega a transferHistory y, si hay bankAddress, llama a executeTransactionRelease(txId) en el banco.

Contrato:

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.30;
import "./LinealQantum.sol";
/**
* @title AdministrativeAuthorizationTransferContract
* @notice Contrato con MultiSig estático (heredado) + MultiSig dinámico (autorizadores administrativos)
*
* FLUJO:
* 1. Operador CREA transacción (NO firma, solo ingresa data) + define 3 wallets autorizadoras
* 2. MultiSig DINÁMICO: 3/3 autorizadores administrativos deben firmar
* 3. MultiSig ESTÁTICO: Signers institucionales/quorum firman (heredado de MultiSigBase)
* 4. EJECUCIÓN: Cuando ambos MultiSig completos → ejecuta
*/
interface ILinealBank {
function executeTransactionRelease(bytes32 txId) external;
}
contract LinealTransactions is LinealQantum {
// ═════════════════════════════════════════════════════════════════════════
// ESTRUCTURAS
// ═════════════════════════════════════════════════════════════════════════
struct TransactionMetadata {
string recipientName;
string motivo;
string documento;
string mensaje;
string tipo;
}
struct QorumTransaction {
address to;
uint256 amount;
bytes32 referenceHash;
address createdBy;
uint256 timestamp;
uint256 expiresAt;
bool executed;
bool cancelled;
address fromAccount;
address tokenAddress;
// Metadatos Institucionales
TransactionMetadata meta;
// MultiSig Dinámico
address[3] administrativeAuthorizers;
mapping(address => bool) hasAuthorized;
uint256 adminSignatures;
bool staticMultiSigCompleted;
}
uint256 public txCounter;
mapping(bytes32 => bool) public referenceHashUsed;
address public bankAddress;
function setBankAddress(address _bank) external onlyGuardian {
bankAddress = _bank;
}
// DEPRECATED: RolesContract removido del sistema
// RolesContract public rolesContract;
// Transacciones administrativas
mapping(bytes32 => QorumTransaction) public transactions;
bytes32[] public transactionIds;
// Historial de transacciones ejecutadas
struct ExecutedTransfer {
address to;
uint256 amount;
bytes32 referenceHash;
address createdBy;
uint256 timestamp;
TransactionMetadata meta;
}
ExecutedTransfer[] public transferHistory;
// Balance simulado
mapping(address => uint256) public entityBalance;
// ═════════════════════════════════════════════════════════════════════════
// EVENTOS
// ═════════════════════════════════════════════════════════════════════════
event TransactionCreated(
bytes32 indexed txId,
address indexed to,
uint256 amount,
bytes32 referenceHash,
address createdBy,
string recipientName,
string tipo
);
event TransactionCancelled(bytes32 indexed txId);
event AdministrativeAuthorized(
bytes32 indexed txId,
address indexed authorizer,
uint256 adminSignatures
);
event StaticMultiSigCompleted(
bytes32 indexed txId
);
event TransactionExecuted(
bytes32 indexed txId,
address indexed to,
uint256 amount,
bytes32 referenceHash
);
// ═════════════════════════════════════════════════════════════════════════
// CONSTRUCTOR
// ═════════════════════════════════════════════════════════════════════════
constructor(
address[] memory _signers,
uint256 _required,
address _guardian,
address _zkVerifier,
uint256 recoveryQorum
) LinealQantum(_signers, _required, _guardian, _zkVerifier, recoveryQorum) {}
// ═════════════════════════════════════════════════════════════════════════
// FASE 1: CREACIÓN (Operador NO firma, solo crea)
// ═════════════════════════════════════════════════════════════════════════
/**
* @notice Operador crea transacción y define 3 autorizadores administrativos
* @param _to Destinatario
* @param _amount Monto
* @param _referenceHash Hash de referencia
* @param _administrativeAuthorizers [3] Wallets que deben autorizar (MultiSig dinámico)
* @return txId ID de la transacción
*/
function createTransaction(
address _to,
uint256 _amount,
bytes32 _referenceHash,
address[3] memory _administrativeAuthorizers,
address _fromAccount,
address _tokenAddress,
TransactionMetadata memory _meta
) external onlySigner returns (bytes32 txId) {
require(_to != address(0), "AAC: invalid recipient");
require(_amount > 0, "AAC: invalid amount");
require(_referenceHash != bytes32(0), "AAC: reference required");
require(!referenceHashUsed[_referenceHash], "AAC: reference already used");
// Validar autorizadores administrativos y separación de deberes
for (uint256 i = 0; i < 3; i++) {
require(_administrativeAuthorizers[i] != address(0), "AAC: invalid authorizer");
require(!_isSigner(_administrativeAuthorizers[i]), "AAC: authorizer cannot be static signer");
for (uint256 j = 0; j < i; j++) {
require(_administrativeAuthorizers[i] != _administrativeAuthorizers[j], "AAC: duplicate authorizer");
}
}
// Generar ID único con contador y encode
txId = keccak256(abi.encode(
_to,
_amount,
_referenceHash,
msg.sender,
block.timestamp,
txCounter++
));
require(transactions[txId].timestamp == 0, "AAC: txId collision");
// Crear transacción
transactions[txId].to = _to;
transactions[txId].amount = _amount;
transactions[txId].referenceHash = _referenceHash;
transactions[txId].createdBy = msg.sender;
transactions[txId].timestamp = block.timestamp;
transactions[txId].expiresAt = block.timestamp + 3 days;
transactions[txId].administrativeAuthorizers = _administrativeAuthorizers;
transactions[txId].fromAccount = _fromAccount;
transactions[txId].tokenAddress = _tokenAddress;
transactions[txId].meta = _meta;
transactionIds.push(txId);
referenceHashUsed[_referenceHash] = true;
emit TransactionCreated(
txId,
_to,
_amount,
_referenceHash,
msg.sender,
_meta.recipientName,
_meta.tipo
);
return txId;
}
// ═════════════════════════════════════════════════════════════════════════
// FASE 2: AUTORIZACIÓN (TODO pasa por MultiSig heredado)
// ═════════════════════════════════════════════════════════════════════════
/**
* @notice Agregador de Consenso 9/9
* Procesa 3 firmas humanas y 6 pruebas ZK de servidores en una sola transacción.
*/
function aggregateConsensus(
bytes32 txId,
bytes[3] calldata humanSignatures,
ZKProof[6] calldata serverProofs,
address[6] calldata serverAddresses
) external {
QorumTransaction storage txn = transactions[txId];
require(txn.timestamp > 0, "AAC: not found");
require(!txn.executed, "AAC: already executed");
// 1. Validar Capa Humana (3/3 Administrativos)
// El hash debe ser el txId firmado por el operador
bytes32 ethHash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", txId));
for (uint256 i = 0; i < 3; i++) {
address authorizer = txn.administrativeAuthorizers[i];
require(!txn.hasAuthorized[authorizer], "AAC: human already authorized");
address signer = _recoverSigner(ethHash, humanSignatures[i]);
require(signer == authorizer, "AAC: invalid human signature");
txn.hasAuthorized[authorizer] = true;
txn.adminSignatures++;
}
// 2. Validar Capa de Servidores (6/6 Institucionales)
// Usamos el hash de acción estándar del contrato
bytes32 actionHash = keccak256(abi.encode("authorizeTransaction", txId));
for (uint256 i = 0; i < 6; i++) {
require(_confirmWithZKFor(actionHash, serverAddresses[i], "authorizeTransaction", serverProofs[i]), "AAC: ZK validation failed");
}
// 3. Verificación de Quorum Estático
if (confirmationCount[actionHash] >= requiredSignatures) {
txn.staticMultiSigCompleted = true;
emit StaticMultiSigCompleted(txId);
}
// 4. Intento de Ejecución Automática
_tryExecute(txId);
}
/**
* @notice Función de consulta para el banco
*/
function getTransactionForBank(bytes32 txId) external view returns (
address to,
uint256 amount,
bool executed,
address fromAccount,
address tokenAddress
) {
QorumTransaction storage txn = transactions[txId];
return (txn.to, txn.amount, txn.executed, txn.fromAccount, txn.tokenAddress);
}
function _recoverSigner(bytes32 _hash, bytes memory _signature) internal pure returns (address) {
if (_signature.length != 65) return address(0);
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(_signature, 32))
s := mload(add(_signature, 64))
v := byte(0, mload(add(_signature, 96)))
}
return ecrecover(_hash, v, r, s);
}
/**
* @notice Autoriza transacción (SIEMPRE a través de MultiSig heredado)
* @dev Valida que caller sea signer de red O autorizador humano definido
* @param txId ID de la transacción
*/
function authorizeTransaction(bytes32 txId) external {
QorumTransaction storage txn = transactions[txId];
require(txn.timestamp > 0, "AAC: transaction not found");
require(!txn.executed, "AAC: already executed");
require(!txn.cancelled, "AAC: cancelled");
require(block.timestamp <= txn.expiresAt, "AAC: expired");
bool isStaticSigner = _isSigner(msg.sender);
bool isHumanAuthorizer = false;
for (uint256 i = 0; i < 3; i++) {
if (txn.administrativeAuthorizers[i] == msg.sender) {
isHumanAuthorizer = true;
break;
}
}
require(
isStaticSigner || isHumanAuthorizer,
"AAC: unauthorized"
);
// BLOQUE C: Generar hash robusto con abi.encode y domain separation
bytes32 actionHash = _computeActionHash(
"authorizeTransaction",
abi.encode(txId)
);
if (isStaticSigner) {
// Usamos el hash único basado en txId para que cada tx tenga su propio ciclo de firmas
if (_confirmActionFor(actionHash, msg.sender, "authorizeTransaction")) {
txn.staticMultiSigCompleted = true;
emit StaticMultiSigCompleted(txId);
}
}
if (isHumanAuthorizer && !txn.hasAuthorized[msg.sender]) {
txn.hasAuthorized[msg.sender] = true;
txn.adminSignatures++;
emit AdministrativeAuthorized(txId, msg.sender, txn.adminSignatures);
}
_tryExecute(txId);
}
/**
* @notice Cancela una transacción. Solo por el creador o por MultiSig.
*/
function cancelTransaction(bytes32 txId) external onlySigner {
QorumTransaction storage txn = transactions[txId];
require(txn.timestamp > 0, "AAC: not found");
require(!txn.executed, "AAC: already executed");
bool isCreator = (msg.sender == txn.createdBy);
bool isMultiSig = false;
// BLOQUE C: Generar hash robusto con abi.encode y domain separation
bytes32 actionHash = _computeActionHash(
"cancelTransaction",
abi.encode(txId)
);
if (!_confirmActionFor(actionHash, msg.sender, "cancelTransaction")) return;
if (isCreator) {
txn.cancelled = true;
emit TransactionCancelled(txId);
}
}
// ═════════════════════════════════════════════════════════════════════════
// FASE 3: EJECUCIÓN (Ambos contadores completos)
// ═════════════════════════════════════════════════════════════════════════
/**
* @notice Intenta ejecutar si ambos thresholds alcanzados
* @dev 3/3 humanos + threshold de red (ambos a través de MultiSig heredado)
*/
function _tryExecute(bytes32 txId) private {
QorumTransaction storage txn = transactions[txId];
if (txn.executed || txn.cancelled) return;
// VALIDAR: 3/3 autorizadores humanos
bool humanAuthorizersComplete = (txn.adminSignatures == 3);
// VALIDAR: MultiSig de red completo (threshold alcanzado)
bool networkMultiSigComplete = txn.staticMultiSigCompleted;
// EJECUTAR solo si AMBOS completos
if (humanAuthorizersComplete && networkMultiSigComplete) {
txn.executed = true;
// Registrar en historial
transferHistory.push(ExecutedTransfer({
to: txn.to,
amount: txn.amount,
referenceHash: txn.referenceHash,
createdBy: txn.createdBy,
timestamp: block.timestamp,
meta: txn.meta
}));
// EJECUCIÓN REAL EN EL BANCO
if (bankAddress != address(0)) {
ILinealBank(bankAddress).executeTransactionRelease(txId);
}
emit TransactionExecuted(
txId,
txn.to,
txn.amount,
txn.referenceHash
);
}
}
// ═════════════════════════════════════════════════════════════════════════
// FUNCIONES DE CONSULTA
// ═════════════════════════════════════════════════════════════════════════
function getTransactionStatus(bytes32 txId) external view returns (
bool exists,
bool executed,
uint256 adminSignatures,
bool adminMultiSigComplete,
bool staticMultiSigComplete,
bool canExecute,
address to,
uint256 amount
) {
QorumTransaction storage txn = transactions[txId];
bool adminComplete = (txn.adminSignatures == 3);
return (
txn.timestamp > 0,
txn.executed,
txn.adminSignatures,
adminComplete,
txn.staticMultiSigCompleted,
adminComplete && txn.staticMultiSigCompleted,
txn.to,
txn.amount
);
}
function getAdministrativeAuthorizers(bytes32 txId) external view returns (address[3] memory) {
return transactions[txId].administrativeAuthorizers;
}
function hasUserAuthorized(bytes32 txId, address user) external view returns (bool) {
return transactions[txId].hasAuthorized[user];
}
function getTransactionIds(uint256 from, uint256 to) external view returns (bytes32[] memory) {
require(from <= to && to < transactionIds.length, "AAC: invalid range");
uint256 size = to - from + 1;
bytes32[] memory result = new bytes32[](size);
for (uint256 i = 0; i < size; i++) {
result[i] = transactionIds[from + i];
}
return result;
}
function getTransferHistory(uint256 from, uint256 to) external view returns (ExecutedTransfer[] memory) {
require(from <= to && to < transferHistory.length, "AAC: invalid range");
uint256 size = to - from + 1;
ExecutedTransfer[] memory result = new ExecutedTransfer[](size);
for (uint256 i = 0; i < size; i++) {
result[i] = transferHistory[from + i];
}
return result;
}
function getTransactionCount() external view returns (uint256) {
return transactionIds.length;
}
function getExecutedTransferCount() external view returns (uint256) {
return transferHistory.length;
}
}