blockchain-api/dist/utils/registry.js

API utilities for interacting with the Exatechl2 blockchain

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AddressType = void 0;
exports.registerAddress = registerAddress;
exports.registerSystemContract = registerSystemContract;
exports.registerTokenContract = registerTokenContract;
exports.registerAddresses = registerAddresses;
exports.unregisterAddress = unregisterAddress;
exports.getAddressInfo = getAddressInfo;
exports.isRegisteredAddress = isRegisteredAddress;
exports.isSystemContract = isSystemContract;
exports.isTokenContract = isTokenContract;
exports.getAddressName = getAddressName;
exports.getAllRegisteredAddresses = getAllRegisteredAddresses;
var AddressType;
(function (AddressType) {
    AddressType["REGULAR"] = "regular";
    AddressType["SYSTEM_CONTRACT"] = "system_contract";
    AddressType["TOKEN_CONTRACT"] = "token_contract";
    AddressType["SPECIAL"] = "special";
})(AddressType || (exports.AddressType = AddressType = {}));
const addressRegistry = new Map();
const defaultAddresses = [
    {
        address: '0x0000000000000000000000000000000000000000',
        name: 'Zero Address',
        type: AddressType.SPECIAL
    }
];
defaultAddresses.forEach(info => {
    addressRegistry.set(info.address.toLowerCase(), {
        ...info,
        address: info.address.toLowerCase()
    });
});
/**
 *
 * @param {string} address
 * @param {string} name
 * @param {AddressType} type
 * @param {Record<string, any>} metadata
 */
function registerAddress(address, name, type = AddressType.REGULAR, metadata) {
    const normalizedAddress = address.toLowerCase();
    addressRegistry.set(normalizedAddress, {
        address: normalizedAddress,
        name,
        type,
        metadata
    });
}
/**
 *
 * @param {string} address
 * @param {string} name
 * @param {Record<string, any>} metadata
 */
function registerSystemContract(address, name, metadata) {
    registerAddress(address, name, AddressType.SYSTEM_CONTRACT, metadata);
}
/**
 *
 * @param {string} address
 * @param {string} name
 * @param {Record<string, any>} metadata
 */
function registerTokenContract(address, name, metadata) {
    registerAddress(address, name, AddressType.TOKEN_CONTRACT, metadata);
}
/**
 *
 * @param {Array} addresses
 */
function registerAddresses(addresses) {
    addresses.forEach(({ address, name, type = AddressType.REGULAR, metadata }) => {
        registerAddress(address, name, type, metadata);
    });
}
/**
 *
 * @param {string} address
 * @returns {boolean}
 */
function unregisterAddress(address) {
    return addressRegistry.delete(address.toLowerCase());
}
/**
 *
 * @param {string} address
 * @returns {RegisteredAddressInfo | null}
 */
function getAddressInfo(address) {
    const normalizedAddress = address.toLowerCase();
    return addressRegistry.has(normalizedAddress)
        ? addressRegistry.get(normalizedAddress) || null
        : null;
}
/**
 *
 * @param {string} address
 * @returns {boolean}
 */
function isRegisteredAddress(address) {
    return addressRegistry.has(address.toLowerCase());
}
/**
 *
 * @param {string} address
 * @returns {boolean}
 */
function isSystemContract(address) {
    const info = getAddressInfo(address);
    return info !== null && info.type === AddressType.SYSTEM_CONTRACT;
}
/**
 *
 * @param {string} address
 * @returns {boolean}
 */
function isTokenContract(address) {
    const info = getAddressInfo(address);
    return info !== null && info.type === AddressType.TOKEN_CONTRACT;
}
/**
 *
 * @param {string} address
 * @returns {string | null}
 */
function getAddressName(address) {
    const info = getAddressInfo(address);
    return info ? info.name : null;
}
/**
 *
 * @param {AddressType} type
 * @returns {Record<string, string>}
 */
function getAllRegisteredAddresses(type) {
    const result = {};
    addressRegistry.forEach((info, address) => {
        if (!type || info.type === type) {
            result[address] = info.name;
        }
    });
    return result;
}