Documentación del contrato

RiskaBeneficiaryRegistry

Guarda las wallets de los beneficiarios y sus porcentajes para cada póliza.

Ver en el exploradorCódigo incluido en este sitio

Red

World Chain Sepolia

Estado

Desplegado en World Chain Sepolia y escribible solo por el policy manager.

Dirección del contrato

0xf248E6AF10ED470B82C3b3c0192e2BbA3d54d06B

Responsabilidades

Guardar cuentas y asignaciones en basis points.
Rechazar conjuntos vacíos, duplicados, con dirección cero o demasiado grandes.
Exigir que los porcentajes sumen 100%.

Mapa de interfaz

setPolicyManager

Define el único contrato autorizado a escribir.

setBeneficiaries

Guarda cuentas y porcentajes.

beneficiaryCount

Devuelve la cantidad de beneficiarios.

beneficiaryAt

Devuelve la wallet y el porcentaje por índice.

Controles de riesgo

Solo escribe el manager configurado.
Máximo ocho beneficiarios por póliza.
Las asignaciones deben sumar exactamente 10,000 basis points.

Código del contrato

El código local de abajo se usa en el despliegue actual de Sepolia.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";

import {RiskaPolicyMath} from "./RiskaPolicyMath.sol";

contract RiskaBeneficiaryRegistry is Ownable {
    struct Beneficiary {
        address account;
        uint16 shareBps;
    }

    uint256 public constant MAX_BENEFICIARIES = 8;

    address public policyManager;

    mapping(uint256 => Beneficiary[]) private policyBeneficiaries;

    event PolicyManagerUpdated(address indexed policyManager);
    event BeneficiariesSet(uint256 indexed policyId, uint256 count);

    modifier onlyPolicyManager() {
        require(msg.sender == policyManager, "ONLY_POLICY_MANAGER");
        _;
    }

    constructor() Ownable(msg.sender) {}

    function setPolicyManager(address nextPolicyManager) external onlyOwner {
        require(nextPolicyManager != address(0), "INVALID_POLICY_MANAGER");
        policyManager = nextPolicyManager;
        emit PolicyManagerUpdated(nextPolicyManager);
    }

    function setBeneficiaries(
        uint256 policyId,
        address[] memory accounts,
        uint16[] memory sharesBps
    ) external onlyPolicyManager {
        require(policyId != 0, "INVALID_POLICY");
        require(accounts.length == sharesBps.length, "BENEFICIARY_LENGTH");
        require(accounts.length <= MAX_BENEFICIARIES, "TOO_MANY_BENEFICIARIES");
        require(accounts.length == 0 || RiskaPolicyMath.validateBeneficiaryShares(sharesBps), "INVALID_SHARES");

        delete policyBeneficiaries[policyId];

        for (uint256 i = 0; i < accounts.length; i++) {
            require(accounts[i] != address(0), "INVALID_BENEFICIARY");

            for (uint256 j = 0; j < i; j++) {
                require(accounts[i] != accounts[j], "DUPLICATE_BENEFICIARY");
            }

            policyBeneficiaries[policyId].push(Beneficiary({account: accounts[i], shareBps: sharesBps[i]}));
        }

        emit BeneficiariesSet(policyId, accounts.length);
    }

    function beneficiaryCount(uint256 policyId) external view returns (uint256) {
        return policyBeneficiaries[policyId].length;
    }

    function beneficiaryAt(uint256 policyId, uint256 index) external view returns (address account, uint16 shareBps) {
        Beneficiary memory beneficiary = policyBeneficiaries[policyId][index];
        return (beneficiary.account, beneficiary.shareBps);
    }
}