Skip to content

Lineal Bank

⏱ 2 min de lectura

Custodia de tokens ERC20 por subcuentas (bytes32 accountId) para una institución. La institución es su owner.

Función Quién Descripción
setTokenSupport owner Habilita o deshabilita depósitos de un token. Los saldos existentes nunca se bloquean
createSubAccount owner Subcuenta institucional. ID: keccak256(name, address(this), block.timestamp, subAccountIds.length)
createCitizenAccount owner Cuenta personal de ciudadano (personalAccount = true)
setRewardsAccount owner Cambia la subcuenta que recibe los fees (no puede ser personal)
setTransactionManager owner Define quién puede llamar executeTransactionRelease
deposit cualquiera Solo tokens habilitados. Acredita lo realmente recibido (soporta tokens con comisión). Sin fee
release owner Retira desde una subcuenta institucional hacia el exterior
releaseFromMyAccount ciudadano Retira desde su propia subcuenta
internalTransfer owner Entre subcuentas del mismo banco. Cobra rewardsBps
zeroFeeInternalTransfer owner Igual, sin fee
moveFromMyAccount ciudadano Mueve fondos desde su subcuenta, con fee
transferToBank owner Hacia una subcuenta de otro banco, con fee. El destino debe soportar el token
individualTransferToBank ciudadano Igual que transferToBank, desde su subcuenta
executeTransactionRelease transactionManager Libera fondos según una transacción validada por LinealTransactions
accountOf(wallet) vista Subcuenta del perfil de una wallet, leída desde LinealCitizens

Fees: rewardsBps (base 10.000) se descuenta en transferencias internas y entre bancos, y se acredita a la subcuenta de rewards en el mismo token. No hay fee si el origen o el destino es la cuenta de rewards.


Contrato:

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.30;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";
import "../../governance/LinealQorum.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/**
* @title LinealToken - NeoQuor
* @notice Stablecoin regulada respaldada 1:1 por moneda FIAT (CLP).
*
* MODELO DE CUMPLIMIENTO:
* - KYC en la entrada: solo se puede acuñar (mint) hacia direcciones en whitelist.
* - Circulación libre: transfer y transferFrom no exigen whitelist.
* - Control reactivo: blacklist administrada por quórum bloquea envíos y recepciones.
* - Recuperación: solo desde cuentas en blacklist, con quórum, razón obligatoria
* y registro público (recoveryHistory).
* - Pausa de emergencia y límites diarios de transferencia, mint y burn.
* - Gobernanza multisig de 3 capas mediante LinealQorum.
* - Auditoría on-chain: mintHistory, burnHistory y recoveryHistory.
*
* @dev El mint y el burn solo los puede ejecutar linealLiquidityAddress.
* El KYC del cliente final se verifica fuera de la cadena antes de whitelistear.
*/
contract LinealToken is ERC20, LinealQorum, Pausable {
// === STATE: ROLES & FLAGS ===
/// @notice Banco que respalda la moneda FIAT (custodia del respaldo).
address public reserveBank;
/// @notice Contrato autorizado a ejecutar mint y burn (liquidez del sistema).
address public linealLiquidityAddress;
/// @notice Indica si el lanzamiento de la fase seed (launchSeed) ya se ejecutó.
bool public launched = false;
/// @notice Bandera de estado reservada para la fase seed; no interviene en la lógica actual.
bool public seedLaunched;
address public linealEconomyAddress;
// === COMPLIANCE & REGULATORY ===
/// @notice Direcciones que pasaron KYC; solo ellas pueden recibir mint o realizar burn.
mapping(address => bool) public isWhitelisted;
/// @notice Direcciones bloqueadas: no pueden enviar ni recibir tokens.
mapping(address => bool) public isBlacklisted;
/// @notice Límite diario de transferencias por dirección emisora (18 decimales).
uint256 public dailyTransferLimit = 27_000_000 * 10**18;
/// @notice Límite diario global de tokens acuñados.
uint256 public dailyMintLimit = 100_000_000 * 10**18;
/// @notice Límite diario global de tokens quemados.
uint256 public dailyBurnLimit = 100_000_000 * 10**18;
struct DailyVolume {
/// @dev Día (timestamp / 1 days) al que corresponde este registro.
uint256 date;
/// @dev Total acuñado en el día.
uint256 minted;
/// @dev Total quemado en el día.
uint256 burned;
/// @dev Volumen transferido en el día, por dirección emisora.
mapping(address => uint256) transferred;
}
/// @notice Volumen diario indexado por día (block.timestamp / 1 days).
mapping(uint256 => DailyVolume) private _dailyVolumes;
// === AUDIT TRAIL: STRUCTS ===
struct MintRecord {
address to;
uint256 amount;
uint256 timestamp;
address authorizedBy;
}
struct BurnRecord {
address from;
uint256 amount;
uint256 timestamp;
address authorizedBy;
}
struct RecoveryRecord {
uint256 id;
address from;
address to;
uint256 amount;
string reason;
uint256 timestamp;
address authorizedBy;
}
// === AUDIT TRAIL: REGISTRIES ===
/// @notice Registro de cada mint.
MintRecord[] public mintHistory;
/// @notice Registro de cada burn.
BurnRecord[] public burnHistory;
/// @notice Registro público de cada recuperación de fondos.
RecoveryRecord[] public recoveryHistory;
// === EVENTS ===
event AddressWhitelisted(address indexed account, bool status);
event Minted(address indexed to, uint256 amount, address indexed authorizedBy, uint256 timestamp);
event Burned(address indexed from, uint256 amount, address indexed authorizedBy, uint256 timestamp);
event ReserveBankSet(address indexed newReserveBank);
event AddressBlacklisted(address indexed account, bool status);
event DailyLimitsUpdated(uint256 transferLimit, uint256 mintLimit, uint256 burnLimit);
event FundsRecovered(
uint256 indexed id,
address indexed from,
address indexed to,
uint256 amount,
string reason,
address authorizedBy,
uint256 timestamp
);
/**
* @notice Inicializa el token y la gobernanza multisig de 3 capas.
* @param name Nombre del token ERC20.
* @param symbol Símbolo del token ERC20.
* @param _machines Signers de la capa máquinas.
* @param _institutions Signers de la capa instituciones.
* @param _humans Signers de la capa humanos.
* @param _requiredMachines Firmas requeridas de la capa máquinas.
* @param _requiredInstitutions Firmas requeridas de la capa instituciones.
* @param _requiredHumans Firmas requeridas de la capa humanos.
* @param _recoveryQuorum Firmas requeridas para recuperaciones.
*/
constructor(
address memory _linealEconomy,
string memory name,
string memory symbol,
address[] memory _machines,
address[] memory _institutions,
address[] memory _humans,
uint256 _requiredMachines,
uint256 _requiredInstitutions,
uint256 _requiredHumans,
uint256 _recoveryQuorum
) LinealQorum(_machines, _requiredMachines, _institutions, _requiredInstitutions, _humans, _requiredHumans, _recoveryQuorum)
ERC20(name, symbol) {
linealEconomyAddress = _linealEconomy;
}
// === MODIFIERS ===
/// @dev Exige que la cuenta haya pasado KYC (whitelist).
modifier onlyWhitelisted(address account) {
require(isWhitelisted[account], "CLP: Address not whitelisted (KYC required)");
_;
}
/// @dev Exige que la cuenta no esté bloqueada por compliance.
modifier notBlacklisted(address account) {
require(!isBlacklisted[account], "CLP: Address is blacklisted");
_;
}
// === EMERGENCY CONTROLS ===
/// @notice Pausa el token (transfer, mint y burn). Requiere quórum.
function pause() external onlyServers {
bytes32 txHash = _computeActionHash("pause", abi.encode(""));
if (!confirm(txHash, "pause")) return;
_pause();
}
/// @notice Reactiva el token. Requiere quórum.
function unpause() external onlyServers {
bytes32 txHash = _computeActionHash("unpause", abi.encode(""));
if (!confirm(txHash, "unpause")) return;
_unpause();
}
// === COMPLIANCE MANAGEMENT ===
/// @notice Agrega o quita una dirección de la whitelist KYC.
function setWhitelist(address account, bool status) external onlyServers {
bytes32 txHash = _computeActionHash("setWhitelist", abi.encode(account, status));
if (!confirmServers(txHash, "setWhitelist")) return;
isWhitelisted[account] = status;
emit AddressWhitelisted(account, status);
}
/// @notice Agrega o quita una dirección de la blacklist.
function setBlacklist(address account, bool status) external onlyServers {
bytes32 txHash = _computeActionHash("setBlacklist", abi.encode(account, status));
if (!confirmServers(txHash, "setBlacklist")) return;
isBlacklisted[account] = status;
emit AddressBlacklisted(account, status);
}
/// @notice Define el contrato de liquidez y acuña el suministro inicial del pre-seed.
/// @dev Solo puede ejecutarse una vez (linealLiquidityAddress debe ser cero).
function launchPreSeed(address _linealLiquidity, uint256 totalAmount) external onlyServers {
bytes32 txHash = _computeActionHash("launchPreSeed", abi.encode(_linealLiquidity, totalAmount));
if (!confirmServers(txHash, "launchPreSeed")) return;
require(linealLiquidityAddress == address(0), "Already Launched");
linealLiquidityAddress = _linealLiquidity;
_mint(_linealLiquidity, totalAmount * 1e18);
}
/// @notice Acuña el suministro de la ronda seed y marca el token como lanzado.
/// @dev Solo puede ejecutarse una vez (launched debe ser false).
function launchSeed(address _linealLiquidity, uint256 totalAmount) external onlyServers {
require(launched == false, "Already Launched");
bytes32 txHash = _computeActionHash("launchSeed", abi.encode(_linealLiquidity, totalAmount));
if (!confirmServers(txHash, "launchSeed")) return;
launched = true;
_mint(_linealLiquidity, totalAmount * 1e18);
}
/// @notice Actualiza los límites diarios de transferencia, mint y burn.
function setDailyLimits(
uint256 _transferLimit,
uint256 _mintLimit,
uint256 _burnLimit
) external onlyServers {
bytes32 txHash = _computeActionHash("setDailyLimits", abi.encode(_transferLimit, _mintLimit, _burnLimit));
if (!confirmServers(txHash, "setDailyLimits")) return;
dailyTransferLimit = _transferLimit;
dailyMintLimit = _mintLimit;
dailyBurnLimit = _burnLimit;
emit DailyLimitsUpdated(_transferLimit, _mintLimit, _burnLimit);
}
// === RESERVE BANK MANAGEMENT ===
/// @notice Vincula el banco de reserva. Solo puede fijarse una vez.
function setReserveBank(address _reserveBank) external onlyServers {
require(reserveBank == address(0), "CLP: Reserve bank already set");
require(_reserveBank != address(0), "CLP: Invalid reserve bank address");
bytes32 txHash = _computeActionHash("setReserveBank", abi.encode(_reserveBank));
if (!confirmServers(txHash, "setReserveBank")) return;
reserveBank = _reserveBank;
emit ReserveBankSet(_reserveBank);
}
// === MINT & BURN (BACKED BY FIAT) ===
/**
* @notice Acuña tokens contra respaldo FIAT.
* @dev Solo el contrato de liquidez puede acuñar, hacia direcciones con KYC
* y fuera de blacklist. Aplica el límite diario global de mint.
* @param to Destino de los tokens.
* @param amount Cantidad a acuñar (18 decimales).
*/
function mint(
address to,
uint256 amount
) external whenNotPaused onlyWhitelisted(to) notBlacklisted(to) {
require(reserveBank != address(0), "CLP: Bank not linked");
require(msg.sender == linealLiquidityAddress, "CLP: Sender is not Authorized Bank");
require(to != address(0), "CLP: Invalid recipient");
require(amount > 0, "CLP: Amount must be > 0");
// Volumen del día actual (se reinicia si cambió el día).
uint256 today = block.timestamp / 1 days;
DailyVolume storage volume = _dailyVolumes[today];
if (volume.date != today) {
volume.date = today;
volume.minted = 0;
}
require(volume.minted + amount <= dailyMintLimit, "CLP: Daily mint limit exceeded");
volume.minted += amount;
// Auditoría on-chain.
mintHistory.push(MintRecord({
to: to,
amount: amount,
timestamp: block.timestamp,
authorizedBy: msg.sender
}));
_mint(to, amount);
emit Minted(to, amount, msg.sender, block.timestamp);
}
/**
* @notice Quema tokens contra retiro de respaldo FIAT.
* @dev Solo el contrato de liquidez puede quemar, desde direcciones con KYC
* y fuera de blacklist. Aplica el límite diario global de burn.
* @param from Dirección de la que se queman los tokens.
* @param amount Cantidad a quemar (18 decimales).
*/
function burn(
address from,
uint256 amount
) external whenNotPaused onlyWhitelisted(from) notBlacklisted(from) {
require(reserveBank != address(0), "CLP: Reserve bank not set");
require(msg.sender == linealLiquidityAddress, "CLP: Sender is not Authorized Bank");
require(from != address(0), "CLP: Invalid address");
require(amount > 0, "CLP: Amount must be > 0");
require(balanceOf(from) >= amount, "CLP: Insufficient balance");
// Volumen del día actual (se reinicia si cambió el día).
uint256 today = block.timestamp / 1 days;
DailyVolume storage volume = _dailyVolumes[today];
if (volume.date != today) {
volume.date = today;
volume.burned = 0;
}
require(volume.burned + amount <= dailyBurnLimit, "CLP: Daily burn limit exceeded");
volume.burned += amount;
// Auditoría on-chain.
burnHistory.push(BurnRecord({
from: from,
amount: amount,
timestamp: block.timestamp,
authorizedBy: msg.sender
}));
_burn(from, amount);
emit Burned(from, amount, msg.sender, block.timestamp);
}
// === FRAUD RECOVERY ===
/**
* @notice Recupera fondos desde una cuenta en blacklist hacia una cuenta limpia.
* @dev Requiere quórum y una razón no vacía; deja registro público en recoveryHistory.
* @param from Cuenta origen (debe estar en blacklist).
* @param to Cuenta destino (no puede estar en blacklist).
* @param amount Cantidad a mover.
* @param reason Justificación de la recuperación (obligatoria).
*/
function recoverFunds(
address from,
address to,
uint256 amount,
string memory reason
) external onlyQorum whenNotPaused {
require(from != address(0) && to != address(0), "CLP: Invalid addresses");
require(from != to, "CLP: Same address");
require(isBlacklisted[from], "CLP: Source is not blacklisted");
require(!isBlacklisted[to], "CLP: Recipient is blacklisted");
require(amount > 0 && balanceOf(from) >= amount, "CLP: Invalid amount");
require(bytes(reason).length > 0, "CLP: Reason required");
bytes32 txHash = _computeActionHash(
"recoverFunds",
abi.encode(from, to, amount, reason)
);
if (!confirm(txHash, "recoverFunds")) return;
uint256 id = recoveryHistory.length;
recoveryHistory.push(RecoveryRecord({
id: id,
from: from,
to: to,
amount: amount,
reason: reason,
timestamp: block.timestamp,
authorizedBy: msg.sender
}));
_transfer(from, to, amount);
emit FundsRecovered(id, from, to, amount, reason, msg.sender, block.timestamp);
}
// === OVERRIDES FOR COMPLIANCE ===
/// @notice Transferencia con control de blacklist, pausa y límite diario del emisor.
function transfer(address to, uint256 amount)
public
override
whenNotPaused
notBlacklisted(msg.sender)
notBlacklisted(to)
returns (bool)
{
_checkAndRecordDailyTransfer(msg.sender, amount);
return super.transfer(to, amount);
}
/// @notice Transferencia con allowance, con control de blacklist, pausa y límite diario del origen.
function transferFrom(address from, address to, uint256 amount)
public
override
whenNotPaused
notBlacklisted(from)
notBlacklisted(to)
returns (bool)
{
_checkAndRecordDailyTransfer(from, amount);
return super.transferFrom(from, to, amount);
}
/**
* @dev Valida y acumula el volumen transferido del día para `account`.
* Reinicia el registro cuando cambia el día.
*/
function _checkAndRecordDailyTransfer(address account, uint256 amount) internal {
uint256 today = block.timestamp / 1 days;
DailyVolume storage volume = _dailyVolumes[today];
if (volume.date != today) {
volume.date = today;
}
require(
volume.transferred[account] + amount <= dailyTransferLimit,
"CLP: Daily transfer limit exceeded"
);
volume.transferred[account] += amount;
}
// === VIEW FUNCTIONS ===
/// @notice Suministro total en circulación.
function getCirculatingSupply() external view returns (uint256) {
return totalSupply();
}
/// @notice Cantidad de registros de mint.
function getMintHistoryLength() external view returns (uint256) {
return mintHistory.length;
}
/// @notice Cantidad de registros de burn.
function getBurnHistoryLength() external view returns (uint256) {
return burnHistory.length;
}
/// @notice Volumen transferido hoy por una dirección.
function getDailyTransferVolume(address account) external view returns (uint256) {
uint256 today = block.timestamp / 1 days;
DailyVolume storage volume = _dailyVolumes[today];
return volume.date == today ? volume.transferred[account] : 0;
}
/// @notice Volumen acuñado y quemado hoy (global).
function getDailyMintBurnVolume() external view returns (uint256 minted, uint256 burned) {
uint256 today = block.timestamp / 1 days;
DailyVolume storage volume = _dailyVolumes[today];
if (volume.date == today) {
return (volume.minted, volume.burned);
}
return (0, 0);
}
// === TRANSPARENCY (RECOVERY HISTORY) ===
/// @notice Cantidad de recuperaciones registradas.
function getRecoveryHistoryLength() external view returns (uint256) {
return recoveryHistory.length;
}
/// @notice Devuelve una página del historial de recuperaciones.
/// @param offset Índice inicial dentro del historial.
/// @param limit Cantidad máxima de registros a devolver.
function getRecoveries(uint256 offset, uint256 limit)
external
view
returns (RecoveryRecord[] memory page)
{
uint256 total = recoveryHistory.length;
if (offset >= total) return new RecoveryRecord[](0);
uint256 end = offset + limit > total ? total : offset + limit;
page = new RecoveryRecord[](end - offset);
for (uint256 i = offset; i < end; i++) {
page[i - offset] = recoveryHistory[i];
}
}
}