Node management interface

1. Safely shut down the node

  • The full name of the interface: safetyClose
  • Interface abbreviation: sfc
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/safetyClose
  • Request parameters:
    interface SafetyClose {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    /**Whether the machine needs to be shut down, true means shutting down false means not shutting down */
    isShutdown?: boolean;
    }
  • Return parameters:
    interface SafetyClose {
    /**whether succeed */
    success: boolean;
    result: {
        /**Node status, see node status for details */
        machineStatus: number;
    };
    }

    2. Set node password

  • The full name of the interface: setSystemKey
  • Interface abbreviation: ssk
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/setSystemKey
  • Request parameters:
    interface SetSystemKey {
    /**Node old password */
    systemKeyOld: string;
    /**Node new password */
    systemKeyNew: string;
    /**Whether to decrypt the new password in asymmetrical way (true: use asymmetrical way for decryption, false: do not use asymmetrical way for decryption, clear text transmission) */
    newKeyDecryptEnable?: boolean;
    }
  • Return parameters:
    interface SetSystemKey {
    /**whether succeed */
    success: boolean;
    result: boolean;
    }

    3. Verify the node password

  • The full name of the interface: verifySystemKey
  • Interface abbreviation: vfs
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/verifySystemKey
  • Request parameters:
    interface VerifySystemKey {
    /**Node password */
    systemKey: string;
    }
  • Return parameters:
    interface VerifySystemKey {
    /**whether succeed */
    success: boolean;
    result: boolean;
    }

    4. Add node administrator

  • The full name of the interface: addSystemAdmin
  • Interface abbreviation: asa
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/addSystemAdmin
  • Request parameters:
    interface AddSystemAdmin {
    /**Node password */
    systemKey: string;
    /**Node administrator address, please refer to <node administrator> for administrator description */
    systemAdminAddress: string;
    }
  • Return parameters:
    interface AddSystemAdmin {
    /**whether succeed */
    success: boolean;
    result: {
        systemAdmin: {
            /**Administrator address */
            adminAddress: string;
            /**Time stamp when the administrator added */
            adminAddTime: number;
            /**Administrator name */
            adminName: string;
        };
    };
    }

    5. Get the node administrator

  • The full name of the interface: getSystemAdmin
  • Interface abbreviation: gsa
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/getSystemAdmin
  • Request parameters:
    interface GetSystemAdmin {
    /**Node password */
    systemKey: string;
    /**Node administrator address, if there is an incoming address, return the information of the administrator address, if not, return the information of all administrators */
    systemAdminAddress?: string;
    }
  • Return parameters:
    interface GetSystemAdmin {
    /**whether succeed */
    success: boolean;
    result: {
        systemAdmin: {
            /**Administrator address */
            adminAddress: string;
            /**Time stamp when the administrator added */
            adminAddTime: number;
            /**Administrator name */
            adminName: string;
        }[];
    };
    }

    6. Verify the node administrator

  • The full name of the interface: verifySystemAdmin
  • Interface abbreviation: vsa
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/verifySystemAdmin
  • Request parameters:
    interface VerifySystemAdmin {
    /**Encrypted administrator address */
    cryptoAdminAddress: string;
    }
  • Return parameters:
    interface VerifySystemAdmin {
    /**whether succeed */
    success: boolean;
    result: boolean;
    }

    7. Delete node administrator

  • The full name of the interface: delSystemAdmin
  • Interface abbreviation: dsa
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/delSystemAdmin
  • Request parameters:
    interface DelSystemAdmin {
    /**Node password */
    systemKey: string;
    /**Node administrator address, please refer to <node administrator> for administrator description */
    systemAdminAddress: string;
    }
  • Return parameters:
    interface DelSystemAdmin {
    /**whether succeed */
    success: boolean;
    result: boolean;
    }

    8. Reset the node administrator

  • The full name of the interface: resetSystemAdmin
  • Interface abbreviation: None
  • Callable methods: Http,Websocket
  • Calling method: post
  • Interface url address: /api/system/resetSystemAdmin
  • Request parameters:
    interface ResetSystemAdmin {
    /**Node password */
    systemKey: string;
    /**Node administrator address, please refer to <node administrator> for administrator description */ 
    systemAdminAddresses: string[];
    }
  • Return parameters:
    interface ResetSystemAdmin {
    /**whether succeed */
    success: boolean;
    result: {
        systemAdmins: {
            /**Administrator address */
            adminAddress: string;
            /**Time stamp when the administrator added */
            adminAddTime: number;
            /**Administrator name */
            adminName: string;
        }[];
    };
    }

    9. Bind node account

  • The full name of the interface: bindingAccount
  • Interface abbreviation: ba
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/bindingAccount
  • Request parameters:
    interface BindingAccount {
    /**Node password */
    systemKey: string;
    /**Encrypted trustee's private key */
    cryptoSecret: string;
    /**Encrypted trustee security key */
    secondSecret?: string;
    }
  • Return parameters:
    interface BindingAccount {
    /**whether succeed */
    success: boolean;
    result: {
        /**Bind account information, JSON object */
        accountInfoAndAsset: MemInfoModel.AccountInfoAndAsset;
    };
    }

    10. Obtain a node trustee

  • The full name of the interface: getSystemDelegate
  • Interface abbreviation: gsd
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/getSystemDelegate
  • Request parameters:
    interface GetSystemDelegate {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    }
  • Return parameters:
    interface GetSystemDelegate {
    /**whether succeed */
    success: boolean;
    result?: {
        /**Node trustee public key */
        publicKey: string;
        /**Node trustee address */
        address: string;
        /**The timestamp when the node trustee is successfully set */
        addTime: number;
        /**Trustee */
        name: string | undefined;
    };
    }

    11.Query all forgers injected by the node

  • The full name of the interface: getInjectGenerators
  • Interface abbreviation: None
  • Callable methods: Http,Websocket
  • Calling method: post
  • Interface url address: /api/system/getInjectGenerators
  • Request parameters:
    interface GetInjectGenerators {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    }
  • Return parameters:
    interface GetInjectGenerators {
    /**whether succeed */
    success: boolean;
    result: {
        /**Array of Forgers */
        injectGenerators: {
            /**Forge address */
            address: string;
            /**Forger username */
            username?: string;
        }[];
    };
    }

    12. Query the details of the forger injected into the node

  • The full name of the interface: getSystemDelegateDetail
  • Interface abbreviation: None
  • Callable methods: Http,Websocket
  • Calling method: post
  • Interface url address: /api/system/getSystemDelegateDetail
  • Request parameters:
    interface GetSystemDelegateDetail {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    /**Trustee address */
    address: string;
    }
  • Return parameters:
    interface GetSystemDelegateDetail {
    /**whether succeed */
    success: boolean;
    result: {
        /**The number of main equity held by the account */
        balance: string;
        /**Account's block revenue */
        reward: string;
        /**Accumulated number of blocks forged by account */
        forgerBlocks: number;
        /**Account address */
        address: string;
        /**Whether it is a trustee */
        isDelegate: boolean;
        /**Account alias */
        username?: string;
    };
    }

    13. Get node details

  • The full name of the interface: getSystemNodeInfo
  • Interface abbreviation: None
  • Callable methods: Http,Websocket
  • Calling method: post
  • Interface url address: /api/system/getSystemNodeInfo
  • Request parameters:
    interface GetSystemNodeInfo {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    }
  • Return parameters:
    interface GetSystemNodeInfo {
    /**whether succeed */
    success: boolean;
    result: {
        nodeInfo: {
            /**Node binding address list */
            addressList: {
                address: string;
                isDelegate: boolean;
                username?: string;
            }[];
            /**The cumulative income of the address bound to the node */
            accumulativeReward: string;
            /**Current height */
            height: number;
            /**Node version */
            version: string;
            /**Chain network identifier */
            magic: string;
            /**Chain name */
            chainName: string;
            /**Node operating system type */
            osType: string;
            /**The signature of the genesis block */
            gensisBlockSignature: string;
        };
    };
    }

    14.Node information query

  • The full name of the interface: miningMachineInfo
  • Interface abbreviation: mmi
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/miningMachineInfo
  • Request parameters:
    interface MiningMachineInfo {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    }
  • Return parameters:
    interface MiningMachineInfo {
    /**whether succeed */
    success: boolean;
    result: {
        data: {
            /**Host name */
            hostname: string;
            /**Update function port */
            updateServicePort: number;
            /**Node management function port */
            systemInfoPort: number;
            /**Service market port */
            serviceMarketPort: number;
            /**Blockchain network port */
            port: number;
            /**operating system */
            platform: string;
            /**CPU core number */
            cpuCount: number;
            /**CPU model information */
            cpuModel: string;
            /**CPU speed */
            cpuSpeed: string;
            /**Memory size unit: byte */
            totalMem: number;
            /**Memory model */
            memModel: string;
            /**Memory Hertz */
            memHz: number;
            /**Disk size unit: byte */
            totalDisk: number;
            /**Disk type */
            diskModel: string;
            /**Whether the node has a trustee set true: the trustee has been set, false: the trustee has not been set */
            delegateStatus: boolean;
        };
    };
    }

    15. Set node configuration information

  • The full name of the interface: setSystemConfig
  • Interface abbreviation: ssc
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/setSystemConfig
  • Request parameters:
    interface SetSystemConfig {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    /**Configuration information, the parameters here can be empty */
    config: AllPartial<Config.ConfigRevisable>;
    }
  • Return parameters:
    interface SetSystemConfig {
    /**whether succeed */
    success: boolean;
    result: boolean;
    }

    16.Get node configuration information

  • The full name of the interface: getSystemConfigInfoDetail
  • Interface abbreviation: gsci
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/getSystemConfigInfoDetail
  • Request parameters:
    interface GetSystemConfigInfoDetail {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    }
  • Return parameters:
    interface GetSystemConfigInfoDetail {
    /**whether succeed */
    success: boolean;
    result: BFChainPC.Config.ConfigReadable;
    }

    17. Obtain node status (real-time information)

  • The full name of the interface: getRuntimeState
  • Interface abbreviation: grs
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/getRuntimeState
  • Request parameters:
    interface GetRuntimeState {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    }
  • Return parameters:
    interface GetRuntimeState {
    /**whether succeed */
    success: boolean;
    result: {
        /**Memory information, JSON object */
        memory: {
            /**The size of the resident set, how much physical memory is allocated to this process */
            rss: number;
            /** The total size of the heap, including 3 parts: 1. Allocated memory, used for object creation and storage, corresponding to heapUsed 2. Unallocated but available for allocation memory 3. Unallocated but not available for allocation Of memory*/
            heapTotal: number;
            /**Allocated memory, that is, the total size of all objects in the heap */
            heapUsed: number;
            /**Memory occupied by the system link library used by the process */
            external: number;
        };
        /**operating system */
        platform:'aix' |'android' |'darwin' |'freebsd' |'linux' |'openbsd' |'sunos' |'win32' |'cygwin' |'netbsd';
        /**CPU core number */
        cpuCount: number;
        /**Available memory size */
        freemem: number;
        /**Total memory size */
        totalmen: number;
        /**CPU usage, unit:% */
        cpuUsage: number;
        /**CPU load average */
        cpuUsageV2: number[];
        /**CPU model information */
        cpuModel: string;
        /**Process information, JSON object */
        process: {
            /**Process ID */
            pid: number;
            /**Process name */
            name?: string;
        };
    };
    }

    18. Get node access statistics

  • The full name of the interface: getSystemMonitor
  • Interface abbreviation: gsm
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/getSystemMonitor
  • Request parameters:
    interface GetSystemMonitor {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    /**Specify the type of access, including access to IP traffic, times, times of access interface, number of blocks, event data, etc. */
    monitorType?: string;
    /**Number of queries, for example, limit=10, which means that 10 pieces of data can be queried. */
    limit?: number;
    /** The starting position of the query, for example, offset = 0, which means that the query starts from the first line. */
    offset?: number;
    }
  • Return parameters:
    interface GetSystemMonitor {
    /**whether succeed */
    success: boolean;
    result: {
        systemMonitor: {
            /**IP statistics */
            requestIpMonitorInfo?: {
                /**IP information object, JSON object */
                    /**Number of visits */
                    requestCount: number;
                    /**Access errors */
                    requestErrorCount: number;
                    /**Access denied times */
                    requestRejectCount: number;
                    /**Download traffic */
                    downloadFlow: number;
                    /**Upstream traffic */
                    uploadFlow: number;
                };
            };
            /**Access method statistics, JSON object */
            requestMethodInfo?: {
                /**Access method statistics, JSON object */
                    /**Number of visits */
                    count: number;
                };
            };
            /**Access path statistics, JSON object */
            requestPathInfo?: {
                /**Access path statistics, JSON object */
                    /**Number of visits */
                    count: number;
                };
            };
            /**Access url statistics, JSON object */
            requestApiUrlInfo?: {
                /**Access url statistics, JSON object */
                    /**Number of visits */
                    count: number;
                };
            };
            /**Access interface name statistics, JSON object */
            requestMethodNameInfo?: {
                /**Access interface name statistics, JSON object */
                    /**Number of visits */
                    count: number;
                };
            };
            /**Access account statistics, JSON object */
            requestAccountInfo?: {
                /**Access account statistics, JSON object */
            };
            /**Statistics of node events, JSON object */
            transaction?: {
                /**Number of node event equity */
                amount: string;
                /**Number of node event fees */
                fee: string;
            };
            /**Statistics on the number of various events of the node, JSON object */
            trsCount?: {
                /**Statistics on the number of various events of the node, JSON object */
            };
            /**Block information, JSON object */
            blockCount?: {
                /**Block height */
                height: number;
                /**Block generation timestamp */
                time: number;
                /**Number of block rewards */
                reward: string;
                /**Block size */
                blockSize: number;
                /**Number of block events */
                numberOfTransactions: number;
            }[];
        };
    };
    }

    19. Obtain the node running log type

  • The full name of the interface: getSystemLoggerType
  • Interface abbreviation: glt
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/getSystemLoggerType
  • Request parameters:
    interface GetSystemLoggerType {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    }
  • Return parameters:
    interface GetSystemLoggerType {
    /**whether succeed */
    success: boolean;
    result: {
        /**Log type, array */
        loggerType: {
            /**Log type */
            loggerType: string;
            /**Log file name */
            loggerName: string;
            /**Number of logs of this type */
            loggerAmount: number;
            /**The total size of this type of log, unit: byte */
            loggerSize: number;
            /** Last creation time of this type of log */
            loggerUpdateTime: number;
        }[];
    };
    }

    20. Get a list of node running logs

  • The full name of the interface: getSystemLoggerList
  • Interface abbreviation: gll
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/getSystemLoggerList
  • Request parameters:
    interface GetSystemLoggerList {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    /**Log type */
    loggerType: string;
    }
  • Return parameters:
    interface GetSystemLoggerList {
    /**whether succeed */
    success: boolean;
    result: {
        /**Node running log list (a certain type of log), JSON object */
        loggerList: {
            /**Log file name */
            logName: string;
            /**Log last modification time */
            logUpdateTime: number;
            /**Log file size */
            logSize: number;
            /**Log file path */
            logPath: string;
        }[];
    };
    }

    21.Obtain the content of the node running log

  • The full name of the interface: getSystemLoggerDetail
  • Interface abbreviation: gld
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/getSystemLoggerDetail
  • Request parameters:
    interface GetSystemLoggerDetail {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    /**Log file name */
    loggerName: string;
    /**Number of queries, for example, limit=10, which means that 10 pieces of data can be queried. */
    limit?: number;
    /** The starting position of the query, for example, offset = 0, which means that the query starts from the first line. */
    offset?: number;
    /**Search string */
    searchString?: string;
    /**How ​​to read files */
    readFileType?: {
        readFileAsync = 0,
        createReadStream = 1,
    };
    }
  • Return parameters:
    interface GetSystemLoggerDetail {
    /**whether succeed */
    success: boolean;
    result: {
        /**Node running log content, array format, content of all detail lines */
        loggerDetail: string[];
        /**Total number of content lines */
        linesTotal: number;
    };
    }

    22. Delete node running log

  • The full name of the interface: delSystemLogger
  • Interface abbreviation: None
  • Callable methods: Http,Websocket
  • Calling method: post
  • Interface url address: /api/system/delSystemLogger
  • Request parameters:
    interface DelSystemLogger {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    /**Log file name */
    loggerName: string;
    }
  • Return parameters:
    interface DelSystemLogger {
    /**whether succeed */
    success: boolean;
    result: boolean;
    }

    23. Obtain the node email address

  • The full name of the interface: getEmailAddress
  • Interface abbreviation: gea
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/getEmailAddress
  • Request parameters:
    interface GetEmailAddress {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    /**The email address to be queried */
    emailAddress?: string;
    }
  • Return parameters:
    interface GetEmailAddress {
    /**whether succeed */
    success: boolean;
    result: {
        /**Mailbox receiving address */
        emailToAddress: string;
        /** Email address */
        emailFromAddress: string;
        /**Mailbox configuration */
        emailConfig: {
            /**Mailbox configuration type, POP3/SMTP/IMAP */
            type: string;
            /**Mailbox configuration host */
            host?: string;
            /**Mailbox configuration port */
            port?: number;
            /** Whether to enable mailbox security control */
            secureConnection?: boolean;
            /**Whether to enable ssl */
            ssl?: boolean;
            /**Whether to open tls */
            tls?: boolean;
            /**Transit mailbox configuration information */
            auth?: {
                /**Transit mailbox configuration user name */
                user: string;
                /**Transit mailbox configuration password */
                pass: string;
            };
        };
    };
    }

    24. Set the node email address

  • The full name of the interface: setEmailAddress
  • Interface abbreviation: sea
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/setEmailAddress
  • Request parameters:
    interface SetEmailAddress {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    /**Mailbox receiving address */
    emailToAddress: string;
    /** Email address */
    emailFromAddress: string;
    /**Mailbox configuration */
    emailConfig: {
        /**Mailbox configuration type, POP3/SMTP/IMAP */
        type: string;
        /**Mailbox configuration host */
        host?: string;
        /**Mailbox configuration port */
        port?: number;
        /** Whether to enable mailbox security control */
        secureConnection?: boolean;
        /**Whether to enable ssl */
        ssl?: boolean;
        /**Whether to open tls */
        tls?: boolean;
        /**Transit mailbox configuration information */
        auth?: {
            /**Transit mailbox configuration user name */
            user: string;
            /**Transit mailbox configuration password */
            pass: string;
        };
    };
    }
  • Return parameters:
    interface SetEmailAddress {
    /**whether succeed */
    success: boolean;
    result: boolean;
    }

    25. Verify the node trustee through the node's private key

  • The full name of the interface: verifySystemSecret
  • Interface abbreviation: vss
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/verifySystemSecret
  • Request parameters:
    interface VerifySystemSecret {
    /**Encrypted trustee's private key */
    cryptoSecret: string;
    }
  • Return parameters:
    interface VerifySystemSecret {
    /**whether succeed */
    success: boolean;
    result: boolean;
    }

    26. Set node access whitelist

  • The full name of the interface: setSystemWhiteList
  • Interface abbreviation: swl
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/setSystemWhiteList
  • Request parameters:
    interface SetSystemWhiteList {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    /**Whitelist list */
    whiteList: string[];
    }
  • Return parameters:
    interface SetSystemWhiteList {
    /**whether succeed */
    success: boolean;
    result: boolean;
    }

    27. Obtain the whitelist of node access

  • The full name of the interface: getSystemWhiteList
  • Interface abbreviation: gwl
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/getSystemWhiteList
  • Request parameters:
    interface GetSystemWhiteList {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    }
  • Return parameters:
    interface GetSystemWhiteList {
    /**whether succeed */
    success: boolean;
    result: {
        /**Whitelist list */
        whileList: string[];
    };
    }

    28. Delete node access whitelist

  • The full name of the interface: delSystemWhiteList
  • Interface abbreviation: dwl
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/delSystemWhiteList
  • Request parameters:
    interface DelSystemWhiteList {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    /**Whitelist list */
    whiteList: string[];
    }
  • Return parameters:
    interface DelSystemWhiteList {
    /**whether succeed */
    success: boolean;
    result: boolean;
    }
  • The full name of the interface: getProcessNetwork
  • Interface abbreviation: gpn
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/getProcessNetwork
  • Request parameters:
    interface GetProcessNetwork {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    /**Number of queries, for example, limit=10, which means that 10 pieces of data can be queried. */
    limit?: number;
    /** The starting position of the query, for example, offset = 0, which means that the query starts from the first line. */
    offset?: number;
    /**Process type */
    processType?: string;
    }
  • Return parameters:
    interface GetProcessNetwork {
    /**whether succeed */
    success: boolean;
    result?: {
        /**Process network information object, JSON object */
        processNetwork: {
            /**Process type */
            processType: string;
            /**Process name */
            name: string;
            /**Process sends network traffic */
            send: number;
            /**Process receives network traffic */
            receive: number;
            /**Total network traffic sent and received by the process */
            sum: number;
        }[];
        count: number;
    };
    }

    30. Obtain the node process CPU information

  • The full name of the interface: getProcessCPU
  • Interface abbreviation: gpc
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/getProcessCPU
  • Request parameters:
    interface GetProcessCPU {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    /**Number of queries, for example, limit=10, which means that 10 pieces of data can be queried. */
    limit?: number;
    /** The starting position of the query, for example, offset = 0, which means that the query starts from the first line. */
    offset?: number;
    /**Process type */
    processType?: string;
    }
  • Return parameters:
    interface GetProcessCPU {
    /**whether succeed */
    success: boolean;
    result?: {
        /**Process CPU status, JSON object */
        processCPU: {
            /**Process type */
            processType: string;
            /**Process name */
            name: string;
            /**Process CPU usage */
            percent: number;
            /**Process CPU status */
            state: string;
        }[];
        count: number;
    };
    }

    31. Get node process memory information

  • The full name of the interface: getProcessMemory
  • Interface abbreviation: gpm
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/getProcessMemory
  • Request parameters:
    interface GetProcessMemory {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    /**Number of queries, for example, limit=10, which means that 10 pieces of data can be queried. */
    limit?: number;
    /** The starting position of the query, for example, offset = 0, which means that the query starts from the first line. */
    offset?: number;
    /**Process type */
    processType?: string;
    }
  • Return parameters:
    interface GetProcessMemory {
    /**whether succeed */
    success: boolean;
    result?: {
        /**Process memory situation, JSON object */
        processMemory: {
            /**Process type */
            processType: string;
            /**Process name */
            name: string;
            /**Process shared memory size */
            share: number;
            /**Process dedicated memory size */
            rss: number;
        }[];
        count: number;
    };
    }

    32. Send node status regularly

  • The full name of the interface: systemStatus
  • Interface abbreviation: ess
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/systemStatus
  • Request parameters:
    interface SystemStatus {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    }
  • Return parameters:
    interface SystemStatus {
    /**whether succeed */
    success: boolean;
    result: {
        systemStatus: {
            /**CPU usage, array */
            cpusStatus: {
                /** Which generation of code name does the CPU belong to in its series */
                model: string;
                /**CPU frequency (clock frequency) */
                speed: number;
                /**Time-consuming statistics */
                times: {
                    /**The number of milliseconds the CPU spends in user mode */
                    user: number;
                    /**The number of milliseconds the CPU spends in good mode */
                    nice: number;
                    /**The number of milliseconds the CPU spends in system mode */
                    sys: number;
                    /**The number of milliseconds the CPU spends in idle mode */
                    idle: number;
                    /**The number of milliseconds the CPU spends in interrupt request mode */
                    irq: number;
                };
            }[];
            /**Memory usage */
            memStatus: {
                /**Available memory size */
                freeMem: number;
                /**Total memory size */
                totalmem: number;
            };
            /**System bandwidth */
            bandwithStatus: {
                /**Total bandwidth */
                total: number;
                /**Use bandwidth */
                usage: number;
            };
            /**Disk usage */
            diskSpace: {
                /**Available disk size */
                free: number;
                /**Total disk size */
                size: number;
            };
            /**Node operating status: 0 offline, unavailable 1 Free state, free resources are available 2 Rebuild the blockchain 3 Node consensus 4 Replay block 5 Forge block 6 Rollback block*/
            machineStatus: number;
            /** Trustee Information */
            deletegateInfo: {
                /**Voting yield */
                reward: string;
                /**The number of votes in the current round */
                voteCount: number;
                /**Number of blocks forged by the trustee */
                forgerBlocks: number;
            };
            /**Miner version name */
            miningMachineVersionName: string;
            /**CPU usage */
            cpuUsage: number;
        };
    };
    }

    33. Send node CPU, memory and network information regularly

  • The full name of the interface: systemProcess
  • Interface abbreviation: esp
  • Callable methods: Http, Websocket, command line, Grpc
  • Calling method: post
  • Interface url address: /api/system/systemProcess
  • Request parameters:
    interface SystemProcess {
    /**Verification type: 001 Node owner verification 002 Administrator verification */
    verifyType: string;
    /**Check value, according to the different permissions of the node visitor, the node owner checks the password, and the administrator checks the address */
    verifyKey: string;
    }
  • Return parameters:
    interface SystemProcess {
    /**whether succeed */
    success: boolean;
    result: {
        /**Node CPU, memory, network information, JSON object */
        systemProcess: {
            /**CPU usage, array */
            usageCPU: {
                // Number of processes
                processCount: number;
                // speed
                speed: number;
                // Uptime
                runtime: number;
                // Threads
                threadCount: number;
                // Number of handles
                handleCount: number;
                // CPU usage
                CPUusage: number;
            };
            /**Memory usage */
            usageMemory: {
                // physical memory
                physcial: number;
                // physical memory usage
                physcialUsed: number;
                // Physical memory is free
                physcialWait: number;
                // Virtual Memory
                virtual: number;
                // Virtual memory usage
                virtualUsed: number;
                // Virtual memory is free
                virtualWait: number;
            };
            /**Network usage */
            usageNetwork: {
                // Receive network traffic
                receive: number;
                // send network traffic
                send: number;
                // Total network traffic
                sum: number;
            };
            /**Process usage status */
            processData: {
                /**CPU usage percentage */
                CPUPercent: number;
                /**Memory usage percentage */
                memoryPercent: number;
                /**Send every second */
                send: number;
                /**Receive per second */
                receive: number;
            };
        };
    };
    }

    34. Obtain node information, and return node information in different forms according to the different input parameters

  • The full name of the interface: getSystemInfo
  • Interface abbreviation: None
  • Callable methods: Http,Websocket
  • Calling method: get
  • Interface url address: /api/system/getSystemInfo
  • Request parameters: none
  • Return parameters:
    interface GetSystemInfo {
    /**whether succeed */
    success: boolean;
    result: {
        data: {
            /**System ip */
            localIp: string;
            /**System Trustee */
            delegateInfo: {
                /**Node trustee public key */
                publicKey: string;
                /**Node trustee address */
                address: string;
                /**The timestamp when the node trustee is successfully set */
                addTime: number;
                /**Trustee */
                name: string | undefined;
            } | undefined;
        };
    };
    }

    35. Get node status

  • The full name of the interface: getMachineStatus
  • Interface abbreviation: None
  • Callable methods: Http,Websocket
  • Calling method: get
  • Interface url address: /api/system/getMachineStatus
  • Request parameters: none
  • Return parameters:
    interface GetMachineStatus {
    /**whether succeed */
    success: boolean;
    result: {
        /**Node status */
        machineStatus: number;
        /**The latest block height of the node */
        height?: number;
    };
    }