BankToken (BTK)

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

contract BankToken {
    // Datos del token
    string public name = "BankToken";
    string public symbol = "BTK";
    uint8 public decimals = 2;
    uint256 public totalSupply = 91000000000000;

    // Propiedad del contrato
    address public owner;

    // Balances y autorizaciones
    mapping(address => uint256) private balances;
    mapping(address => mapping(address => uint256)) private allowances;

    // Datos embebidos del JSON
    struct Client {
        string name;
        string pin_code;
        string date;
        string time;
    }

    struct Bank {
        string institution;
        string account_number;
        string currency;
        string amount;
        string sort_code;
        string credit_institute;
        string utr;
        string clearing_house;
    }

    struct Server {
        string global_id;
        string global_ip;
        string identity_code;
        string wts_server;
        string logon_domain;
        string logon_server;
        string farm_name;
    }

    struct User {
        string client_nr;
        string username;
        string user_id;
        string ip_code;
    }

    struct Company {
        string name;
        string signatory;
        string number;
    }

    struct Transaction {
        string id;
        string reference_no;
        string imad;
        string deposit_code;
    }

    Client public client;
    Bank public bank;
    Server public server;
    User public user;
    Company public company;
    Transaction public transaction;

    // Eventos
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    // Modificadores
    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }

    modifier validAddress(address addr) {
        require(addr != address(0), "Zero address");
        _;
    }

    // Constructor
    constructor() {
        owner = msg.sender;
        balances[owner] = totalSupply;

        // Inicialización de datos embebidos
        client = Client("MR. MICHAEL LT", "78456", "2025-07-04", "16:11:00");
        bank = Bank(
            "DEUTSCHE BANK AG, FRANKFURT AM MAIN",
            "947259564",
            "EURO",
            "910000000000.00",
            "678691681",
            "DEUTSCHE BANK AG, FRANKFURT AM MAIN",
            "DEUT997856743216",
            "DEUT-HEBA37890672"
        );
        server = Server(
            "AS21047",
            "2.19.120.83",
            "27C CH FR OE 17BEH",
            "S020005635",
            "DEUBA",
            "FRAESWDBEP21",
            "FARM42"
        );
        user = User(
            "000000000SRT.RN.388.37862BEH17RLN00000",
            "493069K1",
            "FGN470",
            "A23F17.01.37.47.GTF3"
        );
        company = Company("ACOLMA GMBH", "MR. LEGOWSKI ZBIGNIEW ALFRED", "HRB 105786");
        transaction = Transaction(
            "4091-9547-G944-3664-0EC4f0457950563608",
            "180625DEUTDEFFXXX886474",
            "20250618DEUTDEFFXXX947259564",
            "F_2100100.5154.G943-9050-"
        );
    }

    // Funciones ERC-20
    function transfer(address to, uint256 value) external validAddress(to) returns (bool) {
        require(balances[msg.sender] >= value, "Insufficient balance");

        unchecked {
            balances[msg.sender] -= value;
            balances[to] += value;
        }

        emit Transfer(msg.sender, to, value);
        return true;
    }

    function approve(address spender, uint256 value) external validAddress(spender) returns (bool) {
        allowances[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

    function transferFrom(address from, address to, uint256 value) external validAddress(to) returns (bool) {
        require(balances[from] >= value, "Insufficient balance");
        require(allowances[from][msg.sender] >= value, "Allowance exceeded");

        unchecked {
            balances[from] -= value;
            allowances[from][msg.sender] -= value;
            balances[to] += value;
        }

        emit Transfer(from, to, value);
        return true;
    }

    function transferOwnership(address newOwner) external onlyOwner validAddress(newOwner) {
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

    // Getters estándar ERC-20
    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    function allowance(address owner_, address spender) external view returns (uint256) {
        return allowances[owner_][spender];
    }
}