merge dev

src/NetscriptFunctions.ts

@@ -82,6 +82,13 @@ import {
   Stanek as IStanek,
   Infiltration as IInfiltration,
   SourceFileLvl,
+  BasicHGWOptions,
+  ProcessInfo,
+  HackingMultipliers,
+  HacknetMultipliers,
+  BitNodeMultipliers as IBNMults,
+  Server as IServerDef,
+  RunningScript as IRunningScriptDef,
 } from "./ScriptEditor/NetscriptDefinitions";
 import { NetscriptSingularity } from "./NetscriptFunctions/Singularity";
 
@@ -165,9 +172,9 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
    *      is not specified.
    */
   const getRunningScript = function (
-    fn: any,
-    hostname: any,
-    callingFnName: any,
+    fn: string,
+    hostname: string,
+    callingFnName: string,
     scriptArgs: any,
   ): RunningScript | null {
     if (typeof callingFnName !== "string" || callingFnName === "") {
@@ -196,7 +203,7 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
     return workerScript.scriptRef;
   };
 
-  const getRunningScriptByPid = function (pid: any, callingFnName: any): RunningScript | null {
+  const getRunningScriptByPid = function (pid: number, callingFnName: string): RunningScript | null {
     if (typeof callingFnName !== "string" || callingFnName === "") {
       callingFnName = "getRunningScriptgetRunningScriptByPid";
     }
@@ -216,7 +223,7 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
    * @param {any[]} scriptArgs - Running script's arguments
    * @returns {string} Error message to print to logs
    */
-  const getCannotFindRunningScriptErrorMessage = function (fn: any, hostname: any, scriptArgs: any): string {
+  const getCannotFindRunningScriptErrorMessage = function (fn: string, hostname: string, scriptArgs: any): string {
     if (!Array.isArray(scriptArgs)) {
       scriptArgs = [];
     }
@@ -231,7 +238,7 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
    * @param {string} callingFn - Name of calling function. For logging purposes
    * @returns {boolean} True if the server is a Hacknet Server, false otherwise
    */
-  const failOnHacknetServer = function (server: any, callingFn: any = ""): boolean {
+  const failOnHacknetServer = function (server: BaseServer, callingFn = ""): boolean {
     if (server instanceof HacknetServer) {
       workerScript.log(callingFn, () => `Does not work on Hacknet Servers`);
       return true;
@@ -319,7 +326,11 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
     }
   };
 
-  const hack = function (hostname: any, manual: any, { threads: requestedThreads, stock }: any = {}): Promise<number> {
+  const hack = function (
+    hostname: string,
+    manual: boolean,
+    { threads: requestedThreads, stock }: any = {},
+  ): Promise<number> {
     if (hostname === undefined) {
       throw makeRuntimeErrorMsg("hack", "Takes 1 argument.");
     }
@@ -450,7 +461,7 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
     getServer: safeGetServer,
     checkSingularityAccess: checkSingularityAccess,
     hack: hack,
-    getValidPort: (funcName: string, port: any): IPort => {
+    getValidPort: (funcName: string, port: number): IPort => {
       if (isNaN(port)) {
         throw makeRuntimeErrorMsg(
           funcName,
@@ -506,7 +517,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
     hacknet: hacknet,
     sprintf: sprintf,
     vsprintf: vsprintf,
-    scan: function (hostname: any = workerScript.hostname): any {
+    scan: function (_hostname: unknown = workerScript.hostname): string[] {
+      const hostname = helper.string("scan", "hostname", _hostname);
       updateDynamicRam("scan", getRamCost(Player, "scan"));
       const server = safeGetServer(hostname, "scan");
       const out = [];
@@ -520,11 +532,14 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       workerScript.log("scan", () => `returned ${server.serversOnNetwork.length} connections for ${server.hostname}`);
       return out;
     },
-    hack: function (hostname: any, { threads: requestedThreads, stock }: any = {}): any {
+    hack: function (_hostname: unknown, { threads: requestedThreads, stock }: BasicHGWOptions = {}): Promise<number> {
+      const hostname = helper.string("hack", "hostname", _hostname);
       updateDynamicRam("hack", getRamCost(Player, "hack"));
       return hack(hostname, false, { threads: requestedThreads, stock: stock });
     },
-    hackAnalyzeThreads: function (hostname: any, hackAmount: any): any {
+    hackAnalyzeThreads: function (_hostname: unknown, _hackAmount: unknown): number {
+      const hostname = helper.string("hackAnalyzeThreads", "hostname", _hostname);
+      const hackAmount = helper.number("hackAnalyzeThreads", "hackAmount", _hackAmount);
       updateDynamicRam("hackAnalyzeThreads", getRamCost(Player, "hackAnalyzeThreads"));
 
       // Check argument validity
@@ -554,43 +569,48 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
 
       return hackAmount / Math.floor(server.moneyAvailable * percentHacked);
     },
-    hackAnalyze: function (hostname: any): any {
+    hackAnalyze: function (_hostname: unknown): number {
+      const hostname = helper.string("hackAnalyze", "hostname", _hostname);
       updateDynamicRam("hackAnalyze", getRamCost(Player, "hackAnalyze"));
 
       const server = safeGetServer(hostname, "hackAnalyze");
       if (!(server instanceof Server)) {
         workerScript.log("hackAnalyze", () => "Cannot be executed on this server.");
-        return false;
+        return 0;
       }
 
       return calculatePercentMoneyHacked(server, Player);
     },
-    hackAnalyzeSecurity: function (threads: any): number {
+    hackAnalyzeSecurity: function (_threads: unknown): number {
+      const threads = helper.number("hackAnalyzeSecurity", "threads", _threads);
       updateDynamicRam("hackAnalyzeSecurity", getRamCost(Player, "hackAnalyzeSecurity"));
       return CONSTANTS.ServerFortifyAmount * threads;
     },
-    hackAnalyzeChance: function (hostname: any): any {
+    hackAnalyzeChance: function (_hostname: unknown): number {
+      const hostname = helper.string("hackAnalyzeChance", "hostname", _hostname);
       updateDynamicRam("hackAnalyzeChance", getRamCost(Player, "hackAnalyzeChance"));
 
       const server = safeGetServer(hostname, "hackAnalyzeChance");
       if (!(server instanceof Server)) {
         workerScript.log("hackAnalyzeChance", () => "Cannot be executed on this server.");
-        return false;
+        return 0;
       }
 
       return calculateHackingChance(server, Player);
     },
-    sleep: function (time: any): any {
+    sleep: async function (_time: unknown = 0): Promise<void> {
+      const time = helper.number("sleep", "time", _time);
       updateDynamicRam("sleep", getRamCost(Player, "sleep"));
       if (time === undefined) {
         throw makeRuntimeErrorMsg("sleep", "Takes 1 argument.");
       }
       workerScript.log("sleep", () => `Sleeping for ${time} milliseconds`);
       return netscriptDelay(time, workerScript).then(function () {
-        return Promise.resolve(true);
+        return Promise.resolve();
       });
     },
-    asleep: function (time: any): any {
+    asleep: function (_time: unknown = 0): Promise<void> {
+      const time = helper.number("asleep", "time", _time);
       updateDynamicRam("asleep", getRamCost(Player, "asleep"));
       if (time === undefined) {
         throw makeRuntimeErrorMsg("asleep", "Takes 1 argument.");
@@ -598,16 +618,24 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       workerScript.log("asleep", () => `Sleeping for ${time} milliseconds`);
       return new Promise((resolve) => setTimeout(resolve, time));
     },
-    grow: function (hostname: any, { threads: requestedThreads, stock }: any = {}): any {
+    grow: async function (
+      _hostname: unknown,
+      { threads: requestedThreads, stock }: BasicHGWOptions = {},
+    ): Promise<number> {
+      const hostname = helper.string("grow", "hostname", _hostname);
       updateDynamicRam("grow", getRamCost(Player, "grow"));
-      const threads = resolveNetscriptRequestedThreads(workerScript, "grow", requestedThreads);
+      const threads = resolveNetscriptRequestedThreads(
+        workerScript,
+        "grow",
+        requestedThreads ?? workerScript.scriptRef.threads,
+      );
       if (hostname === undefined) {
         throw makeRuntimeErrorMsg("grow", "Takes 1 argument.");
       }
       const server = safeGetServer(hostname, "grow");
       if (!(server instanceof Server)) {
         workerScript.log("grow", () => "Cannot be executed on this server.");
-        return false;
+        return Promise.resolve(0);
       }
 
       const host = GetServer(workerScript.hostname);
@@ -653,14 +681,17 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         return Promise.resolve(moneyAfter / moneyBefore);
       });
     },
-    growthAnalyze: function (hostname: any, growth: any, cores: any = 1): any {
+    growthAnalyze: function (_hostname: unknown, _growth: unknown, _cores: unknown = 1): number {
+      const hostname = helper.string("growthAnalyze", "hostname", _hostname);
+      const growth = helper.number("growthAnalyze", "growth", _growth);
+      const cores = helper.number("growthAnalyze", "cores", _cores);
       updateDynamicRam("growthAnalyze", getRamCost(Player, "growthAnalyze"));
 
       // Check argument validity
       const server = safeGetServer(hostname, "growthAnalyze");
       if (!(server instanceof Server)) {
         workerScript.log("growthAnalyze", () => "Cannot be executed on this server.");
-        return false;
+        return 0;
       }
       if (typeof growth !== "number" || isNaN(growth) || growth < 1 || !isFinite(growth)) {
         throw makeRuntimeErrorMsg("growthAnalyze", `Invalid argument: growth must be numeric and >= 1, is ${growth}.`);
@@ -668,20 +699,26 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
 
       return numCycleForGrowth(server, Number(growth), Player, cores);
     },
-    growthAnalyzeSecurity: function (threads: any): number {
+    growthAnalyzeSecurity: function (_threads: unknown): number {
+      const threads = helper.number("growthAnalyzeSecurity", "threads", _threads);
       updateDynamicRam("growthAnalyzeSecurity", getRamCost(Player, "growthAnalyzeSecurity"));
       return 2 * CONSTANTS.ServerFortifyAmount * threads;
     },
-    weaken: function (hostname: any, { threads: requestedThreads }: any = {}): any {
+    weaken: async function (_hostname: unknown, { threads: requestedThreads }: BasicHGWOptions = {}): Promise<number> {
+      const hostname = helper.string("weaken", "hostname", _hostname);
       updateDynamicRam("weaken", getRamCost(Player, "weaken"));
-      const threads = resolveNetscriptRequestedThreads(workerScript, "weaken", requestedThreads);
+      const threads = resolveNetscriptRequestedThreads(
+        workerScript,
+        "weaken",
+        requestedThreads ?? workerScript.scriptRef.threads,
+      );
       if (hostname === undefined) {
         throw makeRuntimeErrorMsg("weaken", "Takes 1 argument.");
       }
       const server = safeGetServer(hostname, "weaken");
       if (!(server instanceof Server)) {
         workerScript.log("weaken", () => "Cannot be executed on this server.");
-        return false;
+        return Promise.resolve(0);
       }
 
       // No root access or skill level too low
@@ -721,12 +758,14 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         return Promise.resolve(CONSTANTS.ServerWeakenAmount * threads * coreBonus);
       });
     },
-    weakenAnalyze: function (threads: any, cores: any = 1): number {
+    weakenAnalyze: function (_threads: unknown, _cores: unknown = 1): number {
+      const threads = helper.number("weakenAnalyze", "threads", _threads);
+      const cores = helper.number("weakenAnalyze", "cores", _cores);
       updateDynamicRam("weakenAnalyze", getRamCost(Player, "weakenAnalyze"));
       const coreBonus = 1 + (cores - 1) / 16;
       return CONSTANTS.ServerWeakenAmount * threads * coreBonus * BitNodeMultipliers.ServerWeakenRate;
     },
-    share: function (): Promise<void> {
+    share: async function (): Promise<void> {
       updateDynamicRam("share", getRamCost(Player, "share"));
       workerScript.log("share", () => "Sharing this computer.");
       const end = StartSharing(workerScript.scriptRef.threads * calculateIntelligenceBonus(Player.intelligence, 2));
@@ -746,7 +785,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       }
       workerScript.print(argsToString(args));
     },
-    printf: function (format: string, ...args: any[]): void {
+    printf: function (_format: unknown, ...args: any[]): void {
+      const format = helper.string("printf", "format", _format);
       updateDynamicRam("printf", getRamCost(Player, "printf"));
       if (typeof format !== "string") {
         throw makeRuntimeErrorMsg("printf", "First argument must be string for the format.");
@@ -777,7 +817,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       }
       Terminal.print(`${workerScript.scriptRef.filename}: ${str}`);
     },
-    tprintf: function (format: any, ...args: any): any {
+    tprintf: function (_format: unknown, ...args: any[]): void {
+      const format = helper.string("printf", "format", _format);
       updateDynamicRam("tprintf", getRamCost(Player, "tprintf"));
       if (typeof format !== "string") {
         throw makeRuntimeErrorMsg("tprintf", "First argument must be string for the format.");
@@ -802,14 +843,15 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       }
       Terminal.print(`${str}`);
     },
-    clearLog: function (): any {
+    clearLog: function (): void {
       updateDynamicRam("clearLog", getRamCost(Player, "clearLog"));
       workerScript.scriptRef.clearLog();
     },
-    disableLog: function (fn: any): any {
+    disableLog: function (_fn: unknown): void {
+      const fn = helper.string("disableLog", "fn", _fn);
       updateDynamicRam("disableLog", getRamCost(Player, "disableLog"));
       if (fn === "ALL") {
-        for (fn of Object.keys(possibleLogs)) {
+        for (const fn of Object.keys(possibleLogs)) {
           workerScript.disableLogs[fn] = true;
         }
         workerScript.log("disableLog", () => `Disabled logging for all functions`);
@@ -820,10 +862,11 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         workerScript.log("disableLog", () => `Disabled logging for ${fn}`);
       }
     },
-    enableLog: function (fn: any): any {
+    enableLog: function (_fn: unknown): void {
+      const fn = helper.string("enableLog", "fn", _fn);
       updateDynamicRam("enableLog", getRamCost(Player, "enableLog"));
       if (fn === "ALL") {
-        for (fn of Object.keys(possibleLogs)) {
+        for (const fn of Object.keys(possibleLogs)) {
           delete workerScript.disableLogs[fn];
         }
         workerScript.log("enableLog", () => `Enabled logging for all functions`);
@@ -833,24 +876,29 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       delete workerScript.disableLogs[fn];
       workerScript.log("enableLog", () => `Enabled logging for ${fn}`);
     },
-    isLogEnabled: function (fn: any): any {
+    isLogEnabled: function (_fn: unknown): boolean {
+      const fn = helper.string("isLogEnabled", "fn", _fn);
       updateDynamicRam("isLogEnabled", getRamCost(Player, "isLogEnabled"));
       if (possibleLogs[fn] === undefined) {
         throw makeRuntimeErrorMsg("isLogEnabled", `Invalid argument: ${fn}.`);
       }
       return !workerScript.disableLogs[fn];
     },
-    getScriptLogs: function (fn: any, hostname: any, ...scriptArgs: any): any {
+    getScriptLogs: function (_fn: unknown, _hostname: unknown, ...scriptArgs: any[]): string[] {
+      const fn = helper.string("getScriptLogs", "fn", _fn);
+      const hostname = helper.string("getScriptLogs", "hostname", _hostname);
       updateDynamicRam("getScriptLogs", getRamCost(Player, "getScriptLogs"));
       const runningScriptObj = getRunningScript(fn, hostname, "getScriptLogs", scriptArgs);
       if (runningScriptObj == null) {
         workerScript.log("getScriptLogs", () => getCannotFindRunningScriptErrorMessage(fn, hostname, scriptArgs));
-        return "";
+        return [];
       }
 
       return runningScriptObj.logs.slice();
     },
-    tail: function (fn: any, hostname: any = workerScript.hostname, ...scriptArgs: any): any {
+    tail: function (_fn: unknown, _hostname: unknown = workerScript.hostname, ...scriptArgs: any[]): void {
+      const fn = helper.string("tail", "fn", _fn);
+      const hostname = helper.string("tail", "hostname", _hostname);
       updateDynamicRam("tail", getRamCost(Player, "tail"));
       let runningScriptObj;
       if (arguments.length === 0) {
@@ -867,7 +915,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
 
       LogBoxEvents.emit(runningScriptObj);
     },
-    nuke: function (hostname: any): boolean {
+    nuke: function (_hostname: unknown): boolean {
+      const hostname = helper.string("tail", "hostname", _hostname);
       updateDynamicRam("nuke", getRamCost(Player, "nuke"));
       if (hostname === undefined) {
         throw makeRuntimeErrorMsg("nuke", "Takes 1 argument.");
@@ -891,7 +940,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       workerScript.log("nuke", () => `Executed NUKE.exe virus on '${server.hostname}' to gain root access.`);
       return true;
     },
-    brutessh: function (hostname: any): boolean {
+    brutessh: function (_hostname: unknown): boolean {
+      const hostname = helper.string("brutessh", "hostname", _hostname);
       updateDynamicRam("brutessh", getRamCost(Player, "brutessh"));
       if (hostname === undefined) {
         throw makeRuntimeErrorMsg("brutessh", "Takes 1 argument.");
@@ -913,7 +963,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       }
       return true;
     },
-    ftpcrack: function (hostname: any): boolean {
+    ftpcrack: function (_hostname: unknown): boolean {
+      const hostname = helper.string("ftpcrack", "hostname", _hostname);
       updateDynamicRam("ftpcrack", getRamCost(Player, "ftpcrack"));
       if (hostname === undefined) {
         throw makeRuntimeErrorMsg("ftpcrack", "Takes 1 argument.");
@@ -935,7 +986,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       }
       return true;
     },
-    relaysmtp: function (hostname: any): boolean {
+    relaysmtp: function (_hostname: unknown): boolean {
+      const hostname = helper.string("relaysmtp", "hostname", _hostname);
       updateDynamicRam("relaysmtp", getRamCost(Player, "relaysmtp"));
       if (hostname === undefined) {
         throw makeRuntimeErrorMsg("relaysmtp", "Takes 1 argument.");
@@ -957,7 +1009,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       }
       return true;
     },
-    httpworm: function (hostname: any): boolean {
+    httpworm: function (_hostname: unknown): boolean {
+      const hostname = helper.string("httpworm", "hostname", _hostname);
       updateDynamicRam("httpworm", getRamCost(Player, "httpworm"));
       if (hostname === undefined) {
         throw makeRuntimeErrorMsg("httpworm", "Takes 1 argument");
@@ -979,7 +1032,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       }
       return true;
     },
-    sqlinject: function (hostname: any): boolean {
+    sqlinject: function (_hostname: unknown): boolean {
+      const hostname = helper.string("sqlinject", "hostname", _hostname);
       updateDynamicRam("sqlinject", getRamCost(Player, "sqlinject"));
       if (hostname === undefined) {
         throw makeRuntimeErrorMsg("sqlinject", "Takes 1 argument.");
@@ -1001,7 +1055,9 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       }
       return true;
     },
-    run: function (scriptname: any, threads: any = 1, ...args: any[]): any {
+    run: function (_scriptname: unknown, _threads: unknown = 1, ...args: any[]): number {
+      const scriptname = helper.string("run", "scriptname", _scriptname);
+      const threads = helper.number("run", "threads", _threads);
       updateDynamicRam("run", getRamCost(Player, "run"));
       if (scriptname === undefined) {
         throw makeRuntimeErrorMsg("run", "Usage: run(scriptname, [numThreads], [arg1], [arg2]...)");
@@ -1016,7 +1072,10 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
 
       return runScriptFromScript(Player, "run", scriptServer, scriptname, args, workerScript, threads);
     },
-    exec: function (scriptname: any, hostname: any, threads: any = 1, ...args: any[]): any {
+    exec: function (_scriptname: unknown, _hostname: unknown, _threads: unknown = 1, ...args: any[]): number {
+      const scriptname = helper.string("exec", "scriptname", _scriptname);
+      const hostname = helper.string("exec", "hostname", _hostname);
+      const threads = helper.number("exec", "threads", _threads);
       updateDynamicRam("exec", getRamCost(Player, "exec"));
       if (scriptname === undefined || hostname === undefined) {
         throw makeRuntimeErrorMsg("exec", "Usage: exec(scriptname, server, [numThreads], [arg1], [arg2]...)");
@@ -1027,7 +1086,9 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       const server = safeGetServer(hostname, "exec");
       return runScriptFromScript(Player, "exec", server, scriptname, args, workerScript, threads);
     },
-    spawn: function (scriptname: any, threads: any = 1, ...args: any[]): any {
+    spawn: function (_scriptname: unknown, _threads: unknown = 1, ...args: any[]): void {
+      const scriptname = helper.string("spawn", "scriptname", _scriptname);
+      const threads = helper.number("spawn", "threads", _threads);
       updateDynamicRam("spawn", getRamCost(Player, "spawn"));
       if (!scriptname || !threads) {
         throw makeRuntimeErrorMsg("spawn", "Usage: spawn(scriptname, threads)");
@@ -1053,7 +1114,9 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         workerScript.log("spawn", () => "Exiting...");
       }
     },
-    kill: function (filename: any, hostname?: any, ...scriptArgs: any): any {
+    kill: function (_filename: unknown, _hostname?: unknown, ...scriptArgs: any[]): boolean {
+      const filename = helper.string("kill", "filename", _filename);
+      const hostname = helper.string("kill", "hostname", _hostname);
       updateDynamicRam("kill", getRamCost(Player, "kill"));
 
       let res;
@@ -1099,7 +1162,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         return false;
       }
     },
-    killall: function (hostname: any = workerScript.hostname): any {
+    killall: function (_hostname: unknown = workerScript.hostname): boolean {
+      const hostname = helper.string("killall", "hostname", _hostname);
       updateDynamicRam("killall", getRamCost(Player, "killall"));
       if (hostname === undefined) {
         throw makeRuntimeErrorMsg("killall", "Takes 1 argument");
@@ -1117,7 +1181,7 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
 
       return scriptsRunning;
     },
-    exit: function (): any {
+    exit: function (): void {
       updateDynamicRam("exit", getRamCost(Player, "exit"));
       workerScript.running = false; // Prevent workerScript from "finishing execution naturally"
       if (killWorkerScript(workerScript)) {
@@ -1126,7 +1190,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         workerScript.log("exit", () => "Failed. This is a bug. Report to dev.");
       }
     },
-    scp: async function (scriptname: any, hostname1: any, hostname2?: any): Promise<boolean> {
+    scp: async function (scriptname: any, _hostname1: unknown, hostname2?: any): Promise<boolean> {
+      const hostname1 = helper.string("scp", "hostname1", _hostname1);
       updateDynamicRam("scp", getRamCost(Player, "scp"));
       if (arguments.length !== 2 && arguments.length !== 3) {
         throw makeRuntimeErrorMsg("scp", "Takes 2 or 3 arguments");
@@ -1283,7 +1348,9 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         newScript.updateRamUsage(Player, destServer.scripts).then(() => resolve(true));
       });
     },
-    ls: function (hostname: any, grep: any): any {
+    ls: function (_hostname: unknown, _grep: unknown = ""): string[] {
+      const hostname = helper.string("ls", "hostname", _hostname);
+      const grep = helper.string("ls", "grep", _grep);
       updateDynamicRam("ls", getRamCost(Player, "ls"));
       if (hostname === undefined) {
         throw makeRuntimeErrorMsg("ls", "Usage: ls(hostname/ip, [grep filter])");
@@ -1350,7 +1417,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       allFiles.sort();
       return allFiles;
     },
-    ps: function (hostname: any = workerScript.hostname): any {
+    ps: function (_hostname: unknown = workerScript.hostname): ProcessInfo[] {
+      const hostname = helper.string("ps", "hostname", _hostname);
       updateDynamicRam("ps", getRamCost(Player, "ps"));
       const server = safeGetServer(hostname, "ps");
       const processes = [];
@@ -1364,7 +1432,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       }
       return processes;
     },
-    hasRootAccess: function (hostname: any): any {
+    hasRootAccess: function (_hostname: unknown): boolean {
+      const hostname = helper.string("hasRootAccess", "hostname", _hostname);
       updateDynamicRam("hasRootAccess", getRamCost(Player, "hasRootAccess"));
       if (hostname === undefined) {
         throw makeRuntimeErrorMsg("hasRootAccess", "Takes 1 argument");
@@ -1372,7 +1441,7 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       const server = safeGetServer(hostname, "hasRootAccess");
       return server.hasAdminRights;
     },
-    getHostname: function (): any {
+    getHostname: function (): string {
       updateDynamicRam("getHostname", getRamCost(Player, "getHostname"));
       const scriptServer = GetServer(workerScript.hostname);
       if (scriptServer == null) {
@@ -1380,13 +1449,13 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       }
       return scriptServer.hostname;
     },
-    getHackingLevel: function (): any {
+    getHackingLevel: function (): number {
       updateDynamicRam("getHackingLevel", getRamCost(Player, "getHackingLevel"));
       Player.updateSkillLevels();
       workerScript.log("getHackingLevel", () => `returned ${Player.hacking}`);
       return Player.hacking;
     },
-    getHackingMultipliers: function (): any {
+    getHackingMultipliers: function (): HackingMultipliers {
       updateDynamicRam("getHackingMultipliers", getRamCost(Player, "getHackingMultipliers"));
       return {
         chance: Player.hacking_chance_mult,
@@ -1395,7 +1464,7 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         growth: Player.hacking_grow_mult,
       };
     },
-    getHacknetMultipliers: function (): any {
+    getHacknetMultipliers: function (): HacknetMultipliers {
       updateDynamicRam("getHacknetMultipliers", getRamCost(Player, "getHacknetMultipliers"));
       return {
         production: Player.hacknet_node_money_mult,
@@ -1405,7 +1474,7 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         levelCost: Player.hacknet_node_level_cost_mult,
       };
     },
-    getBitNodeMultipliers: function (): any {
+    getBitNodeMultipliers: function (): IBNMults {
       updateDynamicRam("getBitNodeMultipliers", getRamCost(Player, "getBitNodeMultipliers"));
       if (SourceFileFlags[5] <= 0 && Player.bitNodeN !== 5) {
         throw makeRuntimeErrorMsg("getBitNodeMultipliers", "Requires Source-File 5 to run.");
@@ -1413,7 +1482,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       const copy = Object.assign({}, BitNodeMultipliers);
       return copy;
     },
-    getServer: function (hostname: any = workerScript.hostname): any {
+    getServer: function (_hostname: unknown = workerScript.hostname): IServerDef {
+      const hostname = helper.string("getServer", "hostname", _hostname);
       updateDynamicRam("getServer", getRamCost(Player, "getServer"));
       const server = safeGetServer(hostname, "getServer");
       const copy = Object.assign({}, server) as any;
@@ -1436,7 +1506,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       if (!copy.serverGrowth) copy.serverGrowth = 0;
       return copy;
     },
-    getServerMoneyAvailable: function (hostname: any): any {
+    getServerMoneyAvailable: function (_hostname: unknown): number {
+      const hostname = helper.string("getServerMoneyAvailable", "hostname", _hostname);
       updateDynamicRam("getServerMoneyAvailable", getRamCost(Player, "getServerMoneyAvailable"));
       const server = safeGetServer(hostname, "getServerMoneyAvailable");
       if (!(server instanceof Server)) {
@@ -1460,7 +1531,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       );
       return server.moneyAvailable;
     },
-    getServerSecurityLevel: function (hostname: any): any {
+    getServerSecurityLevel: function (_hostname: unknown): number {
+      const hostname = helper.string("getServerSecurityLevel", "hostname", _hostname);
       updateDynamicRam("getServerSecurityLevel", getRamCost(Player, "getServerSecurityLevel"));
       const server = safeGetServer(hostname, "getServerSecurityLevel");
       if (!(server instanceof Server)) {
@@ -1476,7 +1548,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       );
       return server.hackDifficulty;
     },
-    getServerBaseSecurityLevel: function (hostname: any): any {
+    getServerBaseSecurityLevel: function (_hostname: unknown): number {
+      const hostname = helper.string("getServerBaseSecurityLevel", "hostname", _hostname);
       updateDynamicRam("getServerBaseSecurityLevel", getRamCost(Player, "getServerBaseSecurityLevel"));
       workerScript.log(
         "getServerBaseSecurityLevel",
@@ -1496,7 +1569,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       );
       return server.baseDifficulty;
     },
-    getServerMinSecurityLevel: function (hostname: any): any {
+    getServerMinSecurityLevel: function (_hostname: unknown): number {
+      const hostname = helper.string("getServerMinSecurityLevel", "hostname", _hostname);
       updateDynamicRam("getServerMinSecurityLevel", getRamCost(Player, "getServerMinSecurityLevel"));
       const server = safeGetServer(hostname, "getServerMinSecurityLevel");
       if (!(server instanceof Server)) {
@@ -1512,7 +1586,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       );
       return server.minDifficulty;
     },
-    getServerRequiredHackingLevel: function (hostname: any): any {
+    getServerRequiredHackingLevel: function (_hostname: unknown): number {
+      const hostname = helper.string("getServerRequiredHackingLevel", "hostname", _hostname);
       updateDynamicRam("getServerRequiredHackingLevel", getRamCost(Player, "getServerRequiredHackingLevel"));
       const server = safeGetServer(hostname, "getServerRequiredHackingLevel");
       if (!(server instanceof Server)) {
@@ -1528,7 +1603,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       );
       return server.requiredHackingSkill;
     },
-    getServerMaxMoney: function (hostname: any): any {
+    getServerMaxMoney: function (_hostname: unknown): number {
+      const hostname = helper.string("getServerMaxMoney", "hostname", _hostname);
       updateDynamicRam("getServerMaxMoney", getRamCost(Player, "getServerMaxMoney"));
       const server = safeGetServer(hostname, "getServerMaxMoney");
       if (!(server instanceof Server)) {
@@ -1544,7 +1620,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       );
       return server.moneyMax;
     },
-    getServerGrowth: function (hostname: any): any {
+    getServerGrowth: function (_hostname: unknown): number {
+      const hostname = helper.string("getServerGrowth", "hostname", _hostname);
       updateDynamicRam("getServerGrowth", getRamCost(Player, "getServerGrowth"));
       const server = safeGetServer(hostname, "getServerGrowth");
       if (!(server instanceof Server)) {
@@ -1557,7 +1634,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       workerScript.log("getServerGrowth", () => `returned ${server.serverGrowth} for '${server.hostname}'`);
       return server.serverGrowth;
     },
-    getServerNumPortsRequired: function (hostname: any): any {
+    getServerNumPortsRequired: function (_hostname: unknown): number {
+      const hostname = helper.string("getServerNumPortsRequired", "hostname", _hostname);
       updateDynamicRam("getServerNumPortsRequired", getRamCost(Player, "getServerNumPortsRequired"));
       const server = safeGetServer(hostname, "getServerNumPortsRequired");
       if (!(server instanceof Server)) {
@@ -1573,7 +1651,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       );
       return server.numOpenPortsRequired;
     },
-    getServerRam: function (hostname: any): any {
+    getServerRam: function (_hostname: unknown): [number, number] {
+      const hostname = helper.string("getServerRam", "hostname", _hostname);
       updateDynamicRam("getServerRam", getRamCost(Player, "getServerRam"));
       workerScript.log(
         "getServerRam",
@@ -1586,23 +1665,28 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       );
       return [server.maxRam, server.ramUsed];
     },
-    getServerMaxRam: function (hostname: any): any {
+    getServerMaxRam: function (_hostname: unknown): number {
+      const hostname = helper.string("getServerMaxRam", "hostname", _hostname);
       updateDynamicRam("getServerMaxRam", getRamCost(Player, "getServerMaxRam"));
       const server = safeGetServer(hostname, "getServerMaxRam");
       workerScript.log("getServerMaxRam", () => `returned ${numeralWrapper.formatRAM(server.maxRam)}`);
       return server.maxRam;
     },
-    getServerUsedRam: function (hostname: any): any {
+    getServerUsedRam: function (_hostname: unknown): number {
+      const hostname = helper.string("getServerUsedRam", "hostname", _hostname);
       updateDynamicRam("getServerUsedRam", getRamCost(Player, "getServerUsedRam"));
       const server = safeGetServer(hostname, "getServerUsedRam");
       workerScript.log("getServerUsedRam", () => `returned ${numeralWrapper.formatRAM(server.ramUsed)}`);
       return server.ramUsed;
     },
-    serverExists: function (hostname: any): any {
+    serverExists: function (_hostname: unknown): boolean {
+      const hostname = helper.string("serverExists", "hostname", _hostname);
       updateDynamicRam("serverExists", getRamCost(Player, "serverExists"));
       return GetServer(hostname) !== null;
     },
-    fileExists: function (filename: any, hostname: any = workerScript.hostname): any {
+    fileExists: function (_filename: unknown, _hostname: unknown = workerScript.hostname): boolean {
+      const filename = helper.string("fileExists", "filename", _filename);
+      const hostname = helper.string("fileExists", "hostname", _hostname);
       updateDynamicRam("fileExists", getRamCost(Player, "fileExists"));
       if (filename === undefined) {
         throw makeRuntimeErrorMsg("fileExists", "Usage: fileExists(scriptname, [server])");
@@ -1626,7 +1710,9 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       const txtFile = getTextFile(filename, server);
       return txtFile != null;
     },
-    isRunning: function (fn: any, hostname: any = workerScript.hostname, ...scriptArgs: any): any {
+    isRunning: function (_fn: unknown, _hostname: unknown = workerScript.hostname, ...scriptArgs: any[]): boolean {
+      const fn = helper.string("isRunning", "fn", _fn);
+      const hostname = helper.string("isRunning", "hostname", _hostname);
       updateDynamicRam("isRunning", getRamCost(Player, "isRunning"));
       if (fn === undefined || hostname === undefined) {
         throw makeRuntimeErrorMsg("isRunning", "Usage: isRunning(scriptname, server, [arg1], [arg2]...)");
@@ -1637,17 +1723,18 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         return getRunningScript(fn, hostname, "isRunning", scriptArgs) != null;
       }
     },
-    getPurchasedServerLimit: function (): any {
+    getPurchasedServerLimit: function (): number {
       updateDynamicRam("getPurchasedServerLimit", getRamCost(Player, "getPurchasedServerLimit"));
 
       return getPurchaseServerLimit();
     },
-    getPurchasedServerMaxRam: function (): any {
+    getPurchasedServerMaxRam: function (): number {
       updateDynamicRam("getPurchasedServerMaxRam", getRamCost(Player, "getPurchasedServerMaxRam"));
 
       return getPurchaseServerMaxRam();
     },
-    getPurchasedServerCost: function (ram: any): any {
+    getPurchasedServerCost: function (_ram: unknown): number {
+      const ram = helper.number("getPurchasedServerCost", "ram", _ram);
       updateDynamicRam("getPurchasedServerCost", getRamCost(Player, "getPurchasedServerCost"));
 
       const cost = getPurchaseServerCost(ram);
@@ -1658,10 +1745,10 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
 
       return cost;
     },
-    purchaseServer: function (aname: any, aram: any): any {
+    purchaseServer: function (_name: unknown, _ram: unknown): string {
+      const name = helper.string("purchaseServer", "name", _name);
+      const ram = helper.number("purchaseServer", "ram", _ram);
       if (arguments.length !== 2) throw makeRuntimeErrorMsg("purchaseServer", "Takes 2 arguments");
-      const name = helper.string("purchaseServer", "name", aname);
-      const ram = helper.number("purchaseServer", "ram", aram);
       updateDynamicRam("purchaseServer", getRamCost(Player, "purchaseServer"));
       let hostnameStr = String(name);
       hostnameStr = hostnameStr.replace(/\s+/g, "");
@@ -1722,7 +1809,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       );
       return newServ.hostname;
     },
-    deleteServer: function (name: any): any {
+    deleteServer: function (_name: unknown): boolean {
+      const name = helper.string("purchaseServer", "name", _name);
       updateDynamicRam("deleteServer", getRamCost(Player, "deleteServer"));
       let hostnameStr = String(name);
       hostnameStr = hostnameStr.replace(/\s\s+/g, "");
@@ -1798,7 +1886,7 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       );
       return false;
     },
-    getPurchasedServers: function (): any {
+    getPurchasedServers: function (): string[] {
       updateDynamicRam("getPurchasedServers", getRamCost(Player, "getPurchasedServers"));
       const res: string[] = [];
       Player.purchasedServers.forEach(function (hostname) {
@@ -1806,7 +1894,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       });
       return res;
     },
-    writePort: function (port: any, data: any = ""): any {
+    writePort: function (_port: unknown, data: any = ""): Promise<any> {
+      const port = helper.number("writePort", "port", _port);
       updateDynamicRam("writePort", getRamCost(Player, "writePort"));
       if (typeof data !== "string" && typeof data !== "number") {
         throw makeRuntimeErrorMsg(
@@ -1817,7 +1906,9 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       const iport = helper.getValidPort("writePort", port);
       return Promise.resolve(iport.write(data));
     },
-    write: function (port: any, data: any = "", mode: any = "a"): any {
+    write: function (_port: unknown, data: any = "", _mode: unknown = "a"): Promise<void> {
+      const port = helper.string("write", "port", _port);
+      const mode = helper.string("write", "mode", _mode);
       updateDynamicRam("write", getRamCost(Player, "write"));
       if (isString(port)) {
         // Write to script or text file
@@ -1870,7 +1961,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         throw makeRuntimeErrorMsg("write", `Invalid argument: ${port}`);
       }
     },
-    tryWritePort: function (port: any, data: any = ""): any {
+    tryWritePort: function (_port: unknown, data: any = ""): Promise<any> {
+      let port = helper.number("tryWritePort", "port", _port);
       updateDynamicRam("tryWritePort", getRamCost(Player, "tryWritePort"));
       if (typeof data !== "string" && typeof data !== "number") {
         throw makeRuntimeErrorMsg(
@@ -1895,14 +1987,16 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         throw makeRuntimeErrorMsg("tryWritePort", `Invalid argument: ${port}`);
       }
     },
-    readPort: function (port: any): any {
+    readPort: function (_port: unknown): any {
+      const port = helper.number("readPort", "port", _port);
       updateDynamicRam("readPort", getRamCost(Player, "readPort"));
       // Read from port
       const iport = helper.getValidPort("readPort", port);
       const x = iport.read();
       return x;
     },
-    read: function (port: any): any {
+    read: function (_port: unknown): string {
+      const port = helper.string("read", "port", _port);
       updateDynamicRam("read", getRamCost(Player, "read"));
       if (isString(port)) {
         // Read from script or text file
@@ -1931,13 +2025,15 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         throw makeRuntimeErrorMsg("read", `Invalid argument: ${port}`);
       }
     },
-    peek: function (port: any): any {
+    peek: function (_port: unknown): any {
+      const port = helper.number("peek", "port", _port);
       updateDynamicRam("peek", getRamCost(Player, "peek"));
       const iport = helper.getValidPort("peek", port);
       const x = iport.peek();
       return x;
     },
-    clear: function (file: any): any {
+    clear: function (_file: unknown): void {
+      const file = helper.string("peek", "file", _file);
       updateDynamicRam("clear", getRamCost(Player, "clear"));
       if (isString(file)) {
         // Clear text file
@@ -1953,20 +2049,23 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       } else {
         throw makeRuntimeErrorMsg("clear", `Invalid argument: ${file}`);
       }
-      return 0;
     },
-    clearPort: function (port: any): any {
+    clearPort: function (_port: unknown): void {
+      const port = helper.number("clearPort", "port", _port);
       updateDynamicRam("clearPort", getRamCost(Player, "clearPort"));
       // Clear port
       const iport = helper.getValidPort("clearPort", port);
-      return iport.clear();
+      iport.clear();
     },
-    getPortHandle: function (port: any): IPort {
+    getPortHandle: function (_port: unknown): IPort {
+      const port = helper.number("getPortHandle", "port", _port);
       updateDynamicRam("getPortHandle", getRamCost(Player, "getPortHandle"));
       const iport = helper.getValidPort("getPortHandle", port);
       return iport;
     },
-    rm: function (fn: any, hostname: any): any {
+    rm: function (_fn: unknown, _hostname: unknown): boolean {
+      const fn = helper.string("rm", "fn", _fn);
+      let hostname = helper.string("rm", "hostname", _hostname);
       updateDynamicRam("rm", getRamCost(Player, "rm"));
 
       if (hostname == null || hostname === "") {
@@ -1981,7 +2080,9 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
 
       return status.res;
     },
-    scriptRunning: function (scriptname: any, hostname: any): any {
+    scriptRunning: function (_scriptname: unknown, _hostname: unknown): boolean {
+      const scriptname = helper.string("scriptRunning", "scriptname", _scriptname);
+      const hostname = helper.string("scriptRunning", "hostname", _hostname);
       updateDynamicRam("scriptRunning", getRamCost(Player, "scriptRunning"));
       const server = safeGetServer(hostname, "scriptRunning");
       for (let i = 0; i < server.runningScripts.length; ++i) {
@@ -1991,7 +2092,9 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       }
       return false;
     },
-    scriptKill: function (scriptname: any, hostname: any): any {
+    scriptKill: function (_scriptname: unknown, _hostname: unknown): boolean {
+      const scriptname = helper.string("scriptKill", "scriptname", _scriptname);
+      const hostname = helper.string("scriptKill", "hostname", _hostname);
       updateDynamicRam("scriptKill", getRamCost(Player, "scriptKill"));
       const server = safeGetServer(hostname, "scriptKill");
       let suc = false;
@@ -2004,11 +2107,13 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       }
       return suc;
     },
-    getScriptName: function (): any {
+    getScriptName: function (): string {
       updateDynamicRam("getScriptName", getRamCost(Player, "getScriptName"));
       return workerScript.name;
     },
-    getScriptRam: function (scriptname: any, hostname: any = workerScript.hostname): any {
+    getScriptRam: function (_scriptname: unknown, _hostname: unknown = workerScript.hostname): number {
+      const scriptname = helper.string("getScriptRam", "scriptname", _scriptname);
+      const hostname = helper.string("getScriptRam", "hostname", _hostname);
       updateDynamicRam("getScriptRam", getRamCost(Player, "getScriptRam"));
       const server = safeGetServer(hostname, "getScriptRam");
       for (let i = 0; i < server.scripts.length; ++i) {
@@ -2018,7 +2123,9 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
       }
       return 0;
     },
-    getRunningScript: function (fn: any, hostname: any, ...args: any[]): any {
+    getRunningScript: function (_fn: unknown, _hostname: unknown, ...args: any[]): IRunningScriptDef | null {
+      const fn = helper.string("getRunningScript", "fn", _fn);
+      const hostname = helper.string("getRunningScript", "hostname", _hostname);
       updateDynamicRam("getRunningScript", getRamCost(Player, "getRunningScript"));
 
       let runningScript;
@@ -2046,7 +2153,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         threads: runningScript.threads,
       };
     },
-    getHackTime: function (hostname: any): any {
+    getHackTime: function (_hostname: unknown = workerScript.hostname): number {
+      const hostname = helper.string("getHackTime", "hostname", _hostname);
       updateDynamicRam("getHackTime", getRamCost(Player, "getHackTime"));
       const server = safeGetServer(hostname, "getHackTime");
       if (!(server instanceof Server)) {
@@ -2059,7 +2167,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
 
       return calculateHackingTime(server, Player) * 1000;
     },
-    getGrowTime: function (hostname: any): any {
+    getGrowTime: function (_hostname: unknown = workerScript.hostname): number {
+      const hostname = helper.string("getGrowTime", "hostname", _hostname);
       updateDynamicRam("getGrowTime", getRamCost(Player, "getGrowTime"));
       const server = safeGetServer(hostname, "getGrowTime");
       if (!(server instanceof Server)) {
@@ -2072,7 +2181,8 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
 
       return calculateGrowTime(server, Player) * 1000;
     },
-    getWeakenTime: function (hostname: any = workerScript.hostname): any {
+    getWeakenTime: function (_hostname: unknown = workerScript.hostname): number {
+      const hostname = helper.string("getWeakenTime", "hostname", _hostname);
       updateDynamicRam("getWeakenTime", getRamCost(Player, "getWeakenTime"));
       const server = safeGetServer(hostname, "getWeakenTime");
       if (!(server instanceof Server)) {
@@ -2114,7 +2224,7 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         return runningScriptObj.onlineMoneyMade / runningScriptObj.onlineRunningTime;
       }
     },
-    getScriptExpGain: function (scriptname?: any, hostname?: any, ...args: any[]): any {
+    getScriptExpGain: function (scriptname?: any, hostname?: any, ...args: any[]): number {
       updateDynamicRam("getScriptExpGain", getRamCost(Player, "getScriptExpGain"));
       if (arguments.length === 0) {
         let total = 0;
@@ -2136,40 +2246,43 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         return runningScriptObj.onlineExpGained / runningScriptObj.onlineRunningTime;
       }
     },
-    nFormat: function (n: any, format: any): any {
+    nFormat: function (_n: unknown, _format: unknown): string {
+      const n = helper.number("nFormat", "n", _n);
+      const format = helper.string("nFormat", "format", _format);
       updateDynamicRam("nFormat", getRamCost(Player, "nFormat"));
-      if (isNaN(n) || isNaN(parseFloat(n)) || typeof format !== "string") {
+      if (isNaN(n)) {
         return "";
       }
 
-      return numeralWrapper.format(parseFloat(n), format);
+      return numeralWrapper.format(n, format);
     },
-    tFormat: function (milliseconds: any, milliPrecision: any = false): any {
+    tFormat: function (_milliseconds: unknown, _milliPrecision: unknown = false): string {
+      const milliseconds = helper.number("tFormat", "milliseconds", _milliseconds);
+      const milliPrecision = helper.boolean(_milliPrecision);
       updateDynamicRam("tFormat", getRamCost(Player, "tFormat"));
       return convertTimeMsToTimeElapsedString(milliseconds, milliPrecision);
     },
-    getTimeSinceLastAug: function (): any {
+    getTimeSinceLastAug: function (): number {
       updateDynamicRam("getTimeSinceLastAug", getRamCost(Player, "getTimeSinceLastAug"));
       return Player.playtimeSinceLastAug;
     },
-    alert: function (message: any): void {
+    alert: function (_message: unknown): void {
+      const message = helper.string("alert", "message", _message);
       updateDynamicRam("alert", getRamCost(Player, "alert"));
-      message = argsToString([message]);
       dialogBoxCreate(message);
     },
-    toast: function (message: any, variant: any = "success", duration: any = 2000): void {
+    toast: function (_message: unknown, _variant: unknown = "success", _duration: unknown = 2000): void {
+      const message = helper.string("toast", "message", _message);
+      const variant = helper.string("toast", "variant", _variant);
+      const duration = helper.number("toast", "duration", _duration);
       updateDynamicRam("toast", getRamCost(Player, "toast"));
       if (!["success", "info", "warning", "error"].includes(variant))
         throw new Error(`variant must be one of "success", "info", "warning", or "error"`);
-
-      message = argsToString([message]);
-      SnackbarEvents.emit(message, variant, duration);
+      SnackbarEvents.emit(message, variant as any, duration);
     },
-    prompt: function (txt: any, options?: { type?: string; options?: string[] }): any {
+    prompt: function (_txt: unknown, options?: { type?: string; options?: string[] }): Promise<boolean | string> {
+      const txt = helper.string("toast", "txt", _txt);
       updateDynamicRam("prompt", getRamCost(Player, "prompt"));
-      if (!isString(txt)) {
-        txt = JSON.stringify(txt);
-      }
 
       return new Promise(function (resolve) {
         PromptEvent.emit({
@@ -2179,7 +2292,14 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         });
       });
     },
-    wget: async function (url: any, target: any, hostname: any = workerScript.hostname): Promise<boolean> {
+    wget: async function (
+      _url: unknown,
+      _target: unknown,
+      _hostname: unknown = workerScript.hostname,
+    ): Promise<boolean> {
+      const url = helper.string("wget", "url", _url);
+      const target = helper.string("wget", "target", _target);
+      const hostname = helper.string("wget", "hostname", _hostname);
       updateDynamicRam("wget", getRamCost(Player, "wget"));
       if (!isScriptFilename(target) && !target.endsWith(".txt")) {
         workerScript.log("wget", () => `Invalid target file: '${target}'. Must be a script or text file.`);
@@ -2217,7 +2337,7 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         });
       });
     },
-    getFavorToDonate: function (): any {
+    getFavorToDonate: function (): number {
       updateDynamicRam("getFavorToDonate", getRamCost(Player, "getFavorToDonate"));
       return Math.floor(CONSTANTS.BaseFavorToDonate * BitNodeMultipliers.RepToDonateToFaction);
     },
@@ -2344,11 +2464,12 @@ export function NetscriptFunctions(workerScript: WorkerScript): NS {
         f();
       }; // Wrap the user function to prevent WorkerScript leaking as 'this'
     },
-    mv: function (host: string, source: string, destination: string): void {
+    mv: function (_host: unknown, _source: unknown, _destination: unknown): void {
+      const host = helper.string("mv", "host", _host);
+      const source = helper.string("mv", "source", _source);
+      const destination = helper.string("mv", "destination", _destination);
       updateDynamicRam("mv", getRamCost(Player, "mv"));
 
-      if (arguments.length != 3) throw makeRuntimeErrorMsg("mv", "Takes 3 argument.");
-
       if (!isValidFilePath(source)) throw makeRuntimeErrorMsg("mv", `Invalid filename: '${source}'`);
       if (!isValidFilePath(destination)) throw makeRuntimeErrorMsg("mv", `Invalid filename: '${destination}'`);