Registro Central del Ecosistema
⏱ 6 min de lectura
LinealKernel es el registro central del protocolo Lineal Qorum Finternet. Existe un solo kernel en toda la red y es el contrato que regula la economía: decide qué contratos pueden emitir, qué bancos son oficiales, qué instituciones existen, qué coins (ERC20) son válidas y qué dominios y apps están autorizados por institución.
¿Por qué existe uno solo?
Section titled “¿Por qué existe uno solo?”No es un contrato por institución: es la fuente de verdad compartida de la red. Una única instancia concentra:
- La lista de emisores autorizados (p. ej. un Liquidity Locker).
- La lista de bancos oficiales.
- El registro de instituciones con su perfil público.
- La lista de coins ERC20 válidas.
- Los DNS y apps autorizados por institución (multi-tenant).
Cada institución, banco o contrato económico consulta al kernel para saber si una operación es válida (institución registrada, coin válida, emisor autorizado). Si existieran varios kernels, dejarían de ser una fuente de verdad. Por eso hay exactamente uno.
Rol en la economía
Section titled “Rol en la economía”LinealKernel regula la economía a través de seis registros:
| Área | Funciones | Efecto on-chain |
|---|---|---|
| Emisores | authorizeIssuer / deauthorizeIssuer |
Autoriza o revoca contratos que liberan o emiten tokens |
| Bancos oficiales | registerBank / deregisterBank |
Marca o desmarca un banco como oficial |
| Instituciones | registerInstitution / updateInstitutionProfile / removeInstitution |
Alta, edición y baja del perfil público |
| Coins | registerCoin / removeCoin |
Valida o quita un ERC20 del ecosistema |
| DNS | authorizeDns / revokeDns |
Dominios autorizados por institución |
| Apps | authorizeApp / revokeApp |
Apps autorizadas por institución |
Cómo se usa desde el resto del protocolo
Section titled “Cómo se usa desde el resto del protocolo”LinealInstitution, al tener un kernel enlazado (setEconomicKernel), valida institución registrada y coin válida antes de pedir firmas.linealLiquidityu otros emisores consultanisAuthorized(account)para saber si pueden emitir/liberar.- Los bancos consultan
isValidCoin(token)antes de habilitar depósitos de un token. - Ninguna de estas consultas requiere pasar por el SDK: son lecturas on-chain al contrato del kernel.
Gobernanza: quórum de servers
Section titled “Gobernanza: quórum de servers”Todas las funciones de escritura están protegidas con onlyServers (capas máquina e institución) y usan confirmServers, que ejecuta cuando se cumple:
machineConfirmations ≥ requiredMachines, yinstitutionConfirmations ≥ requiredInstitutions.
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. La primera llamada abre la propuesta; la llamada que completa el quórum ejecuta el cambio en esa misma transacción.
Principios de entrada y salida:
Section titled “Principios de entrada y salida:”Por defecto, todas las instituciones y ciudadanos tendrán el derecho de entrar de forma libre.
¿Cómo y porqué se agrega al blacklist una dirección?
El protocolo cuenta con un agente de inteligencia artificial llamado “Eva Threat Intelligence”. Eva es un agente forense que escanea internet, entre portales, foros, exploradores de bloques, canales de telegram, noticias en búsqueda de direcciones asociadas o vinculadas a ataques de infraestructura. Para falsos positivos. Eva debe encontrar al menos 3 fuentes distintas para agregar una wallet a la blacklist del Kernel. Esta medida es para mitigar el peligro de que dinero ilícito contamine la cadena de valor y proteja la integridad de la red. De una manera proactiva y no reactiva. Para que este sistema funcione de la mejor manera. Los exchanges y entidades que operan criptomonedas deben disponer de canales para exponer de la manera más rápida posible las direcciones asociadas a los ataques. Para que Eva pueda seguir el arbol de transacciones y enlistar las transacciones de los valores sustraidos y mapear la trayectoria de los activos.
En caso de que el dinero haya entrado al sistema. Éste no podrá realizar peticiones on-chain y será bloqueado de manera off-chain y on-chain, al requerir triple consenso este bloqueo tiene un delay importante. Para acortar esta brecha se sumará a la capa off-chain de bloqueo para interactuar con los nodos. Bajo la lógica de autenticación de Lineal Qorum Finternet, el hacker no tiene acceso a exportar la clave semilla por diseño de software. Tendrá que pasar por algún nodo autorizado del kernel los cuales harán la validación y detendrán la petición.
Constructor
Section titled “Constructor”constructor( address[] memory _machines, address[] memory _institutionSigners, address[] memory _humans, uint256 _requiredMachines, uint256 _requiredInstitutions, uint256 _requiredHumans, uint256 _recoveryQuorum)Delega en LinealQorum las tres capas de firmantes (machines, institutionSigners, humans), sus umbrales y el recoveryQuorum para la rotación de firmantes (con RECOVERY_DELAY de 2 horas).
Funciones
Section titled “Funciones”Emisores
Section titled “Emisores”| Función | Descripción |
|---|---|
authorizeIssuer(address _issuer) |
Autoriza un contrato (ej. Liquidity Locker) a liberar/emitir tokens. |
deauthorizeIssuer(address _issuer) |
Revoca la autorización de emisión. |
Bancos
Section titled “Bancos”| Función | Descripción |
|---|---|
registerBank(address _bank) |
Registra un banco como oficial del sistema. |
deregisterBank(address _bank) |
Quita un banco de la lista de oficiales. |
Instituciones
Section titled “Instituciones”| Función | Descripción |
|---|---|
registerInstitution(address institution, string name, string description, string imageUrl) |
Registra el perfil público. La dirección debe ser un contrato y no estar registrada antes. |
updateInstitutionProfile(address institution, string name, string description, string imageUrl) |
Actualiza nombre, descripción e imagen de una institución registrada. |
removeInstitution(address institution) |
Elimina el perfil y sus DNS y apps autorizados (swap-and-pop). |
| Función | Descripción |
|---|---|
registerCoin(address token) |
Registra un ERC20 como coin válida. Lee name, symbol y decimals directo del token y verifica que responda totalSupply. |
removeCoin(address token) |
Quita una coin de la lista de válidas (swap-and-pop). |
| Función | Descripción |
|---|---|
authorizeDns(address institution, string dns) |
Autoriza un dominio para una institución registrada. |
revokeDns(address institution, string dns) |
Revoca un dominio (swap-and-pop). |
| Función | Descripción |
|---|---|
authorizeApp(address institution, string appId) |
Autoriza una app (bundle id, package name o URL) para una institución registrada. |
revokeApp(address institution, string appId) |
Revoca una app (swap-and-pop). |
Reglas de validación
Section titled “Reglas de validación”| Campo | Regla |
|---|---|
name |
1–64 bytes (MAX_NAME_LENGTH) |
description |
0–512 bytes (MAX_DESCRIPTION_LENGTH) |
imageUrl |
Obligatoria, 1–256 bytes (MAX_IMAGE_URL_LENGTH) |
dns |
Minúsculas, dígitos, . y -; 3–253 caracteres; sin punto al inicio ni al final. Exigir minúsculas evita duplicados como App.com y app.com |
appId |
1–128 caracteres; sin espacios ni caracteres de control |
MAX_ACCESS_ENTRIES |
Hasta 50 DNS y 50 apps por institución |
coin |
Debe ser un contrato ERC20 con totalSupply, name, symbol y decimals legibles |
Vistas
Section titled “Vistas”| Vista | Descripción |
|---|---|
isAuthorized(account) |
true si es emisor autorizado o banco oficial |
isInstitutionRegistered(institution) |
true si la institución está registrada |
getInstitution(institution) |
Perfil público de una institución |
getInstitutionsCount() |
Cantidad de instituciones |
getInstitutions(offset, limit) |
Lista paginada de perfiles |
isValidCoin(token) |
true si la coin está registrada |
getCoin(token) |
Metadata de una coin válida |
getCoinsCount() |
Cantidad de coins válidas |
getCoins(offset, limit) |
Lista paginada de coins |
getAuthorizedDns(institution) |
DNS autorizados de una institución |
getAuthorizedApps(institution) |
Apps autorizadas de una institución |
isDnsAuthorized(institution, dns) |
Consulta puntual O(1) |
isAppAuthorized(institution, appId) |
Consulta puntual O(1) |
Eventos
Section titled “Eventos”| Evento | Cuándo se emite |
|---|---|
IssuerAuthorized / IssuerDeauthorized |
Alta/baja de emisor |
BankRegistered / BankDeregistered |
Alta/baja de banco oficial |
InstitutionRegistered |
Alta de institución |
InstitutionProfileUpdated |
Actualización de perfil |
InstitutionRemoved |
Baja de institución |
CoinRegistered / CoinRemoved |
Alta/baja de coin |
DnsAuthorized / DnsRevoked |
Alta/baja de DNS |
AppAuthorized / AppRevoked |
Alta/baja de app |
Además hereda de
LinealQorumlos eventos del ciclo de gobernanza:ActionProposed,ActionConfirmed,ActionExecuted,RecoveryProposed,RecoveryConfirmed,RecoveryExecuted.
// SPDX-License-Identifier: UNLICENSEDpragma solidity ^0.8.30;
import "../governance/LinealQorum.sol";import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
interface ICitizensContract {function owner() external view returns (address);function subAccountOf(address wallet) external view returns (bytes32);}/*** @author NeoQuor - Tech Artisan* @title LinealKernel - Lineal Qorum Finternet* @dev Registro de emisores, bancos oficiales, perfiles de instituciones,* coins ERC20 válidas y DNS/apps autorizadas por institución.* Todo cambio requiere quórum de servers.*/contract LinealKernel is LinealQorum {
// ───────────── Tipos ─────────────
struct InstitutionProfile { address institution; // dirección del contrato LinealInstitution string name; string description; string imageUrl; uint256 registeredAt; uint256 updatedAt; }
struct Coin { address token; string name; string symbol; uint8 decimals; uint256 registeredAt; }
// ───────────── Constantes ─────────────
uint256 public constant MAX_NAME_LENGTH = 64; uint256 public constant MAX_DESCRIPTION_LENGTH = 512; uint256 public constant MAX_IMAGE_URL_LENGTH = 256; uint256 public constant MAX_ACCESS_ENTRIES = 50; // por institución y por lista uint256 public constant MAX_DNS_LENGTH = 253; uint256 public constant MAX_APP_ID_LENGTH = 128;
// ───────────── Estado ─────────────
// Emisores y bancos mapping(address => bool) public authorizedIssuers; mapping(address => bool) public officialBanks;
// Perfiles de instituciones mapping(address => InstitutionProfile) private _profiles; mapping(address => uint256) private _institutionIndex; // posición + 1 (0 = no existe) address[] private _institutions;
// Coins válidas mapping(address => Coin) private _coins; mapping(address => uint256) private _coinIndex; // posición + 1 (0 = no existe) address[] private _coinList;
// DNS y apps autorizadas por institución mapping(address => string[]) private _dnsList; mapping(address => mapping(bytes32 => uint256)) private _dnsIndex; // posición + 1 mapping(address => string[]) private _appList; mapping(address => mapping(bytes32 => uint256)) private _appIndex; // posición + 1
// ───────────── Eventos ─────────────
event IssuerAuthorized(address indexed issuer); event IssuerDeauthorized(address indexed issuer); event BankRegistered(address indexed bank); event BankDeregistered(address indexed bank);
event InstitutionRegistered(address indexed institution, string name, string description, string imageUrl); event InstitutionProfileUpdated(address indexed institution, string name, string description, string imageUrl); event InstitutionRemoved(address indexed institution);
event CoinRegistered(address indexed token, string name, string symbol, uint8 decimals); event CoinRemoved(address indexed token);
event DnsAuthorized(address indexed institution, string dns); event DnsRevoked(address indexed institution, string dns); event AppAuthorized(address indexed institution, string appId); event AppRevoked(address indexed institution, string appId);
// ───────────── Errores ─────────────
error InvalidAddress(); error NotAContract(); error InvalidName(); error DescriptionTooLong(); error InvalidImageUrl(); error InstitutionAlreadyRegistered(); error InstitutionNotFound(); error InvalidCoin(); error CoinAlreadyRegistered(); error CoinNotFound(); error InvalidDns(); error InvalidAppId(); error AlreadyAuthorized(); error NotAuthorized(); error TooManyEntries();
constructor( address[] memory _machines, address[] memory _institutionSigners, address[] memory _humans, uint256 _requiredMachines, uint256 _requiredInstitutions, uint256 _requiredHumans, uint256 _recoveryQuorum ) LinealQorum( _machines, _requiredMachines, _institutionSigners, _requiredInstitutions, _humans, _requiredHumans, _recoveryQuorum ) {}
// ═════════════ EMISORES ═════════════
/// @notice Autoriza a un contrato (ej. un Liquidity Locker) a liberar tokens. function authorizeIssuer(address _issuer) external onlyServers { bytes32 txHash = _computeActionHash("authorizeIssuer", abi.encode(_issuer)); if (!confirmServers(txHash, "authorizeIssuer")) return; authorizedIssuers[_issuer] = true; emit IssuerAuthorized(_issuer); }
/// @notice Revoca la autorización de emisión. function deauthorizeIssuer(address _issuer) external onlyServers { bytes32 txHash = _computeActionHash("deauthorizeIssuer", abi.encode(_issuer)); if (!confirmServers(txHash, "deauthorizeIssuer")) return; authorizedIssuers[_issuer] = false; emit IssuerDeauthorized(_issuer); }
// ═════════════ BANCOS ═════════════
/// @notice Registra un banco como oficial del sistema. function registerBank(address _bank) external onlyServers { bytes32 txHash = _computeActionHash("registerBank", abi.encode(_bank)); if (!confirmServers(txHash, "registerBank")) return; officialBanks[_bank] = true; emit BankRegistered(_bank); }
/// @notice Quita a un banco de la lista de oficiales. function deregisterBank(address _bank) external onlyServers { bytes32 txHash = _computeActionHash("deregisterBank", abi.encode(_bank)); if (!confirmServers(txHash, "deregisterBank")) return; officialBanks[_bank] = false; emit BankDeregistered(_bank); }
// ═════════════ PERFILES DE INSTITUCIONES ═════════════
/** * @notice Registra el perfil público de una institución. * @param institution Dirección del contrato de la institución. * @param name Nombre (obligatorio, máx. 64 bytes). * @param description Descripción (máx. 512 bytes). * @param imageUrl URL o URI de la imagen (obligatoria, máx. 256 bytes). */ function registerInstitution( address institution, string calldata name, string calldata description, string calldata imageUrl ) external onlyServers { if (institution == address(0)) revert InvalidAddress(); if (institution.code.length == 0) revert NotAContract(); if (_institutionIndex[institution] != 0) revert InstitutionAlreadyRegistered(); _validateProfile(name, description, imageUrl);
bytes32 txHash = _computeActionHash( "registerInstitution", abi.encode(institution, name, description, imageUrl) ); if (!confirmServers(txHash, "registerInstitution")) return;
InstitutionProfile storage p = _profiles[institution]; p.institution = institution; p.name = name; p.description = description; p.imageUrl = imageUrl; p.registeredAt = block.timestamp; p.updatedAt = block.timestamp;
_institutions.push(institution); _institutionIndex[institution] = _institutions.length;
emit InstitutionRegistered(institution, name, description, imageUrl); }
/// @notice Actualiza nombre, descripción e imagen de una institución registrada. function updateInstitutionProfile( address institution, string calldata name, string calldata description, string calldata imageUrl ) external onlyServers { if (_institutionIndex[institution] == 0) revert InstitutionNotFound(); _validateProfile(name, description, imageUrl);
bytes32 txHash = _computeActionHash( "updateInstitutionProfile", abi.encode(institution, name, description, imageUrl) ); if (!confirmServers(txHash, "updateInstitutionProfile")) return;
InstitutionProfile storage p = _profiles[institution]; p.name = name; p.description = description; p.imageUrl = imageUrl; p.updatedAt = block.timestamp;
emit InstitutionProfileUpdated(institution, name, description, imageUrl); }
/// @notice Elimina el perfil de una institución (y sus DNS/apps autorizadas). function removeInstitution(address institution) external onlyServers { uint256 idx = _institutionIndex[institution]; if (idx == 0) revert InstitutionNotFound();
bytes32 txHash = _computeActionHash("removeInstitution", abi.encode(institution)); if (!confirmServers(txHash, "removeInstitution")) return;
// swap-and-pop uint256 last = _institutions.length; if (idx != last) { address moved = _institutions[last - 1]; _institutions[idx - 1] = moved; _institutionIndex[moved] = idx; } _institutions.pop(); delete _institutionIndex[institution]; delete _profiles[institution]; _clearAccess(institution);
emit InstitutionRemoved(institution); }
// ═════════════ COINS VÁLIDAS ═════════════
/** * @notice Registra un ERC20 como coin válida del ecosistema. * @dev Nombre, símbolo y decimales se leen directo del token. */ function registerCoin(address token) external onlyServers { if (token == address(0)) revert InvalidAddress(); if (_coinIndex[token] != 0) revert CoinAlreadyRegistered();
(string memory n, string memory s, uint8 d) = _readMetadata(token);
bytes32 txHash = _computeActionHash("registerCoin", abi.encode(token)); if (!confirmServers(txHash, "registerCoin")) return;
_coins[token] = Coin({ token: token, name: n, symbol: s, decimals: d, registeredAt: block.timestamp }); _coinList.push(token); _coinIndex[token] = _coinList.length;
emit CoinRegistered(token, n, s, d); }
/// @notice Quita una coin de la lista de válidas. function removeCoin(address token) external onlyServers { uint256 idx = _coinIndex[token]; if (idx == 0) revert CoinNotFound();
bytes32 txHash = _computeActionHash("removeCoin", abi.encode(token)); if (!confirmServers(txHash, "removeCoin")) return;
uint256 last = _coinList.length; if (idx != last) { address moved = _coinList[last - 1]; _coinList[idx - 1] = moved; _coinIndex[moved] = idx; } _coinList.pop(); delete _coinIndex[token]; delete _coins[token];
emit CoinRemoved(token); }
// ═════════════ DNS AUTORIZADOS ═════════════
/// @notice Autoriza un dominio para una institución registrada. /// @param dns Dominio en minúsculas, sin protocolo ni ruta (ej. "app.miinstitucion.cl"). function authorizeDns(address institution, string calldata dns) external onlyServers { if (_institutionIndex[institution] == 0) revert InstitutionNotFound(); if (!_validDns(dns)) revert InvalidDns(); bytes32 key = keccak256(bytes(dns)); if (_dnsIndex[institution][key] != 0) revert AlreadyAuthorized(); if (_dnsList[institution].length >= MAX_ACCESS_ENTRIES) revert TooManyEntries();
bytes32 txHash = _computeActionHash("authorizeDns", abi.encode(institution, dns)); if (!confirmServers(txHash, "authorizeDns")) return;
_dnsList[institution].push(dns); _dnsIndex[institution][key] = _dnsList[institution].length; emit DnsAuthorized(institution, dns); }
/// @notice Revoca un dominio. function revokeDns(address institution, string calldata dns) external onlyServers { bytes32 key = keccak256(bytes(dns)); uint256 idx = _dnsIndex[institution][key]; if (idx == 0) revert NotAuthorized();
bytes32 txHash = _computeActionHash("revokeDns", abi.encode(institution, dns)); if (!confirmServers(txHash, "revokeDns")) return;
string[] storage list = _dnsList[institution]; uint256 last = list.length; if (idx != last) { string memory moved = list[last - 1]; list[idx - 1] = moved; _dnsIndex[institution][keccak256(bytes(moved))] = idx; } list.pop(); delete _dnsIndex[institution][key]; emit DnsRevoked(institution, dns); }
// ═════════════ APPS AUTORIZADAS ═════════════
/// @notice Autoriza una app para una institución registrada. /// @param appId Identificador de la app (bundle id, package name o URL). function authorizeApp(address institution, string calldata appId) external onlyServers { if (_institutionIndex[institution] == 0) revert InstitutionNotFound(); if (!_validAppId(appId)) revert InvalidAppId(); bytes32 key = keccak256(bytes(appId)); if (_appIndex[institution][key] != 0) revert AlreadyAuthorized(); if (_appList[institution].length >= MAX_ACCESS_ENTRIES) revert TooManyEntries();
bytes32 txHash = _computeActionHash("authorizeApp", abi.encode(institution, appId)); if (!confirmServers(txHash, "authorizeApp")) return;
_appList[institution].push(appId); _appIndex[institution][key] = _appList[institution].length; emit AppAuthorized(institution, appId); }
/// @notice Revoca una app. function revokeApp(address institution, string calldata appId) external onlyServers { bytes32 key = keccak256(bytes(appId)); uint256 idx = _appIndex[institution][key]; if (idx == 0) revert NotAuthorized();
bytes32 txHash = _computeActionHash("revokeApp", abi.encode(institution, appId)); if (!confirmServers(txHash, "revokeApp")) return;
string[] storage list = _appList[institution]; uint256 last = list.length; if (idx != last) { string memory moved = list[last - 1]; list[idx - 1] = moved; _appIndex[institution][keccak256(bytes(moved))] = idx; } list.pop(); delete _appIndex[institution][key]; emit AppRevoked(institution, appId); }
// ═════════════ INTERNAS ═════════════
function _validateProfile( string calldata name, string calldata description, string calldata imageUrl ) internal pure { uint256 n = bytes(name).length; if (n == 0 || n > MAX_NAME_LENGTH) revert InvalidName(); if (bytes(description).length > MAX_DESCRIPTION_LENGTH) revert DescriptionTooLong(); uint256 u = bytes(imageUrl).length; if (u == 0 || u > MAX_IMAGE_URL_LENGTH) revert InvalidImageUrl(); }
/// @dev Verifica que sea un contrato ERC20 con metadata legible. function _readMetadata(address token) internal view returns (string memory n, string memory s, uint8 d) { if (token.code.length == 0) revert InvalidCoin(); IERC20Metadata t = IERC20Metadata(token); try t.totalSupply() returns (uint256) {} catch { revert InvalidCoin(); } try t.name() returns (string memory _n) { n = _n; } catch { revert InvalidCoin(); } try t.symbol() returns (string memory _s) { s = _s; } catch { revert InvalidCoin(); } try t.decimals() returns (uint8 _d) { d = _d; } catch { revert InvalidCoin(); } }
/// @dev Minúsculas, dígitos, '.' y '-'; sin punto al inicio o final. /// Exigir minúsculas evita duplicados como "App.com" y "app.com". function _validDns(string calldata dns) internal pure returns (bool) { bytes calldata b = bytes(dns); uint256 n = b.length; if (n < 3 || n > MAX_DNS_LENGTH) return false; if (b[0] == 0x2E || b[n - 1] == 0x2E) return false; for (uint256 i; i < n; i++) { bytes1 c = b[i]; bool ok = (c >= 0x61 && c <= 0x7A) || (c >= 0x30 && c <= 0x39) || c == 0x2D || c == 0x2E; if (!ok) return false; } return true; }
/// @dev Sin caracteres de control ni espacios. function _validAppId(string calldata appId) internal pure returns (bool) { bytes calldata b = bytes(appId); if (b.length == 0 || b.length > MAX_APP_ID_LENGTH) return false; for (uint256 i; i < b.length; i++) { if (uint8(b[i]) <= 0x20 || uint8(b[i]) == 0x7F) return false; } return true; }
/// @dev Limpia DNS y apps de una institución (se usa al removerla). function _clearAccess(address institution) internal { string[] storage d = _dnsList[institution]; for (uint256 i; i < d.length; i++) { delete _dnsIndex[institution][keccak256(bytes(d[i]))]; } delete _dnsList[institution];
string[] storage a = _appList[institution]; for (uint256 i; i < a.length; i++) { delete _appIndex[institution][keccak256(bytes(a[i]))]; } delete _appList[institution]; }
// ═════════════ VISTAS ═════════════
/// @notice Verifica si un caller está autorizado para operar sobre la economía. function isAuthorized(address _account) external view returns (bool) { return authorizedIssuers[_account] || officialBanks[_account]; }
// Instituciones
function isInstitutionRegistered(address institution) external view returns (bool) { return _institutionIndex[institution] != 0; }
function getInstitution(address institution) external view returns (InstitutionProfile memory) { if (_institutionIndex[institution] == 0) revert InstitutionNotFound(); return _profiles[institution]; }
function getInstitutionsCount() external view returns (uint256) { return _institutions.length; }
/// @notice Lista paginada de perfiles para paneles y apps. function getInstitutions(uint256 offset, uint256 limit) external view returns (InstitutionProfile[] memory page) { uint256 total = _institutions.length; if (offset >= total) return new InstitutionProfile[](0); uint256 end = offset + limit > total ? total : offset + limit; page = new InstitutionProfile[](end - offset); for (uint256 i = offset; i < end; i++) { page[i - offset] = _profiles[_institutions[i]]; } }
// Coins
function isValidCoin(address token) external view returns (bool) { return _coinIndex[token] != 0; }
function getCoin(address token) external view returns (Coin memory) { if (_coinIndex[token] == 0) revert CoinNotFound(); return _coins[token]; }
function getCoinsCount() external view returns (uint256) { return _coinList.length; }
/// @notice Lista paginada de coins válidas. function getCoins(uint256 offset, uint256 limit) external view returns (Coin[] memory page) { uint256 total = _coinList.length; if (offset >= total) return new Coin[](0); uint256 end = offset + limit > total ? total : offset + limit; page = new Coin[](end - offset); for (uint256 i = offset; i < end; i++) { page[i - offset] = _coins[_coinList[i]]; } }
// DNS y apps
function getAuthorizedDns(address institution) external view returns (string[] memory) { return _dnsList[institution]; }
function getAuthorizedApps(address institution) external view returns (string[] memory) { return _appList[institution]; }
function isDnsAuthorized(address institution, string calldata dns) external view returns (bool) { return _dnsIndex[institution][keccak256(bytes(dns))] != 0; }
function isAppAuthorized(address institution, string calldata appId) external view returns (bool) { return _appIndex[institution][keccak256(bytes(appId))] != 0; }}Errores personalizados
Section titled “Errores personalizados”error InvalidAddress();error NotAContract();error InvalidName();error DescriptionTooLong();error InvalidImageUrl();error InstitutionAlreadyRegistered();error InstitutionNotFound();error InvalidCoin();error CoinAlreadyRegistered();error CoinNotFound();error InvalidDns();error InvalidAppId();error AlreadyAuthorized();error NotAuthorized();error TooManyEntries();Relación con el resto de la documentación
Section titled “Relación con el resto de la documentación”- Protocolo de contratos:
protocol/whitepapper.md - Infraestructura y consenso:
protocol/infraestructure.md - Seguridad y análisis de riesgos:
technical/security.md
