add description for revive booster

For anyone who prefers certain alerts to be replayable (QTCC, etc.).

Works on Clem, Maroo, Arbitration, SP Incursions, Kuva Siphon, Nightmare and special alerts like QTCC & Void Corruption and probably more.

Reviewed-on: #3012
Reviewed-by: Sainan <63328889+sainan@users.noreply.github.com>
Co-authored-by: Animan8000 <animan8000@noreply.localhost>
Co-committed-by: Animan8000 <animan8000@noreply.localhost>

.coderabbit.yaml

@@ -0,0 +1,19 @@
+# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json
+language: "en-US"
+early_access: false
+reviews:
+    profile: "chill"
+    request_changes_workflow: false
+    changed_files_summary: false
+    high_level_summary: false
+    poem: false
+    review_status: true
+    commit_status: false
+    collapse_walkthrough: false
+    sequence_diagrams: false
+    related_prs: false
+    auto_review:
+        enabled: true
+        drafts: false
+chat:
+    auto_reply: true

.dockerignore

@@ -0,0 +1,8 @@
+**/.dockerignore
+**/.git
+Dockerfile*
+.*
+docker-data/
+node_modules/
+static/data/
+logs/

.env.example

@@ -1,4 +0,0 @@
-# Docker may need a .env file for the following settings:
-DATABASE_PORT=27017 
-DATABASE_USERNAME=root
-DATABASE_PASSWORD=database

.eslintrc

@@ -1,35 +1,48 @@
 {
+    "plugins": ["@typescript-eslint", "prettier", "import"],
     "extends": [
         "eslint:recommended",
         "plugin:@typescript-eslint/recommended",
-        "plugin:@typescript-eslint/recommended-requiring-type-checking"
+        "plugin:@typescript-eslint/recommended-requiring-type-checking",
+        "plugin:import/recommended",
+        "plugin:import/typescript"
     ],
-    "plugins": ["@typescript-eslint", "prettier"],
     "env": {
         "browser": true,
         "es6": true,
         "node": true
     },
     "rules": {
-        "@typescript-eslint/explicit-function-return-type": "warn",
-        "@typescript-eslint/explicit-module-boundary-types": "warn",
-        "@typescript-eslint/restrict-template-expressions": "warn",
-        "@typescript-eslint/restrict-plus-operands": "warn",
-        "@typescript-eslint/no-unsafe-member-access": "warn",
-        "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_" }],
-        "@typescript-eslint/no-misused-promises": "warn",
+        "@typescript-eslint/consistent-type-imports": "error",
+        "@typescript-eslint/explicit-function-return-type": "error",
+        "@typescript-eslint/restrict-template-expressions": "error",
+        "@typescript-eslint/restrict-plus-operands": "error",
+        "@typescript-eslint/no-unsafe-member-access": "error",
+        "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_", "caughtErrors": "none" }],
         "@typescript-eslint/no-unsafe-argument": "error",
-        "@typescript-eslint/no-unsafe-call": "warn",
-        "@typescript-eslint/no-unsafe-assignment": "warn",
-        "@typescript-eslint/no-explicit-any": "warn",
-        "@typescript-eslint/no-loss-of-precision": "warn",
-        "no-case-declarations": "warn",
+        "@typescript-eslint/no-unsafe-call": "error",
+        "@typescript-eslint/no-unsafe-assignment": "error",
+        "@typescript-eslint/no-explicit-any": "off",
+        "no-loss-of-precision": "error",
+        "@typescript-eslint/no-unnecessary-condition": "error",
+        "@typescript-eslint/no-base-to-string": "off",
+        "no-case-declarations": "error",
         "prettier/prettier": "error",
-        "@typescript-eslint/semi": "error",
-        "no-mixed-spaces-and-tabs": "error"
+        "no-mixed-spaces-and-tabs": "error",
+        "@typescript-eslint/require-await": "error",
+        "import/no-named-as-default-member": "off",
+        "import/no-cycle": "warn",
+        "@typescript-eslint/no-deprecated": "warn"
     },
     "parser": "@typescript-eslint/parser",
     "parserOptions": {
         "project": "./tsconfig.json"
+    },
+    "settings": {
+        "import/extensions": [ ".ts" ],
+        "import/resolver": {
+            "typescript": true,
+            "node": true
+        }
     }
 }

.gitattributes

@@ -1,4 +1,4 @@
 # Auto detect text files and perform LF normalization
-* text=auto
+* text=auto eol=lf
 
 static/webui/libs/ linguist-vendored

.github/workflows/build.yml

@@ -1,22 +1,29 @@
 name: Build
 on:
-    push: {}
+    push:
+        branches: ["main"]
     pull_request: {}
 jobs:
     build:
         runs-on: ubuntu-latest
-        strategy:
-            matrix:
-                version: [18, 20, 22]
         steps:
             - name: Checkout
               uses: actions/checkout@v4.1.2
             - name: Setup Node.js environment
               uses: actions/setup-node@v4.0.2
               with:
-                  node-version: ${{ matrix.version }}
+                  node-version: ">=20.18.1"
             - run: npm ci
-            - run: cp config.json.example config.json
-            - run: echo '{"version":"","buildLabel":"","matchmakingBuildId":""}' > static/data/buildConfig.json
-            - run: npm run build
-            - run: npm run lint
+            - run: cp config-vanilla.json config.json
+            - run: npm run verify
+            - run: npm run lint:ci
+            - run: npm run prettier
+            - run: npm run update-translations
+            - name: Fail if there are uncommitted changes
+              run: |
+                  if [[ -n "$(git status --porcelain)" ]]; then
+                    echo "Uncommitted changes detected:"
+                    git status
+                    git --no-pager diff
+                    exit 1
+                  fi

.github/workflows/docker.yml

@@ -0,0 +1,27 @@
+name: Build Docker image
+on:
+    push:
+        branches:
+            - main
+jobs:
+    docker:
+        if: github.repository == 'OpenWF/SpaceNinjaServer'
+        runs-on: ubuntu-latest
+        steps:
+            - name: Set up Docker buildx
+              uses: docker/setup-buildx-action@v3
+            - name: Log in to container registry
+              uses: docker/login-action@v3
+              with:
+                  username: openwf
+                  password: ${{ secrets.DOCKERHUB_TOKEN }}
+            - name: Build and push
+              uses: docker/build-push-action@v6
+              with:
+                  platforms: linux/arm64,linux/amd64
+                  push: true
+                  tags: |
+                      openwf/spaceninjaserver:latest
+                      openwf/spaceninjaserver:latest-arm64
+                      openwf/spaceninjaserver:${{ github.sha }}
+                      openwf/spaceninjaserver:${{ github.sha }}-arm64

.gitignore

@@ -15,4 +15,7 @@ yarn.lock
 /logs
 
 # MongoDB VSCode extension playground scripts
-/database_scripts
+/database_scripts
+
+# Default Docker directory
+/docker-data

.prettierignore

@@ -1,2 +1,5 @@
+src/routes/api.ts
 static/webui/libs/
 *.html
+*.md
+config-vanilla.json

.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+  "recommendations": ["dbaeumer.vscode-eslint"]
+}

.vscode/launch.json

@@ -0,0 +1,18 @@
+// Use IntelliSense to learn about possible attributes.
+// Hover to view descriptions of existing attributes.
+// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Debug and Watch",
+      "args": ["${workspaceFolder}/scripts/dev.js"],
+      "console": "integratedTerminal"
+    }
+  ]
+}
+
+//can use "console": "internalConsole" for VS Code's Debug Console. For that, forceConsole in logger.ts is needed to be true
+//"internalConsoleOptions": "openOnSessionStart" can be useful then

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "typescript.preferences.preferTypeOnlyAutoImports": true
+}

CONTRIBUTING.md

@@ -0,0 +1,19 @@
+## In General
+
+### Prerequisites
+
+Use `npm i` or `npm ci` to install all dependencies, including dev dependencies.
+
+### Development Process
+
+Auto reloading is supported for server and WebUI development. Simply use `npm run dev` or `npm run dev:bun` to start the server and edit away.
+
+### Testing
+
+Before submitting a PR:
+- Use `npm run verify` to verify that the code is type-safe.
+- Use `npm run fix` to fix formatting issues as well as be informed of any unfixable issues. Avoid introducing new warnings.
+
+## WebUI Specific
+
+The translation system is designed around additions being made to `static/webui/translations/en.js`. They are copied over for translation via `npm run update-translations`. DO NOT provide translations generated by AI or other automated tools.

Dockerfile

@@ -1,5 +1,11 @@
-FROM mongo as base
+FROM node:24-alpine3.21
 
-EXPOSE 27017
+RUN apk add --no-cache bash jq
 
-CMD ["mongod"]
+COPY . /app
+WORKDIR /app
+
+RUN npm i --omit=dev --omit=optional
+RUN date '+%d %B %Y' > BUILD_DATE
+
+ENTRYPOINT ["/app/docker-entrypoint.sh"]

README.md

@@ -1,3 +1,41 @@
 # Space Ninja Server
 
 More information for the moment here: [https://discord.gg/PNNZ3asUuY](https://discord.gg/PNNZ3asUuY)
+
+## Project Status
+
+This project is in active development at <https://onlyg.it/OpenWF/SpaceNinjaServer>.
+
+To get an idea of what functionality you can expect to be missing [have a look through the issues](https://onlyg.it/OpenWF/SpaceNinjaServer/issues). However, many things have been implemented and *should* work as expected. Please open an issue for anything where that's not the case and/or the server is reporting errors.
+
+## config.json
+
+SpaceNinjaServer requires a `config.json`. To set it up, you can copy the [config-vanilla.json](config-vanilla.json), which has most cheats disabled.
+
+- `skipTutorial` affects only newly created accounts, so you may wish to change it before logging in for the first time.
+- `logger.level` can be `fatal`, `error`, `warn`, `info`, `http`, `debug`, or `trace`.
+- `ircExecutable` can be provided with a relative path to an EXE which will be ran as a child process of SpaceNinjaServer.
+- `ircAddress`, `hubAddress`, and `nrsAddress` can be provided if these secondary servers are on a different machine.
+- `worldState.eidolonOverride` can be set to `day` or `night` to lock the time to day/fass and night/vome on Plains of Eidolon/Cambion Drift.
+- `worldState.vallisOverride` can be set to `warm` or `cold` to lock the temperature on Orb Vallis.
+- `worldState.duviriOverride` can be set to `joy`, `anger`, `envy`, `sorrow`, or `fear` to lock the Duviri spiral.
+- `worldState.nightwaveOverride` will lock the nightwave season, assuming the client is new enough for it. Valid values:
+  - `RadioLegionIntermission14Syndicate` for Nora's Mix: Dreams of the Dead
+  - `RadioLegionIntermission13Syndicate` for Nora's Mix Vol. 9
+  - `RadioLegionIntermission12Syndicate` for Nora's Mix Vol. 8
+  - `RadioLegionIntermission11Syndicate` for Nora's Mix Vol. 7
+  - `RadioLegionIntermission10Syndicate` for Nora's Mix Vol. 6
+  - `RadioLegionIntermission9Syndicate` for Nora's Mix Vol. 5
+  - `RadioLegionIntermission8Syndicate` for Nora's Mix Vol. 4
+  - `RadioLegionIntermission7Syndicate` for Nora's Mix Vol. 3
+  - `RadioLegionIntermission6Syndicate` for Nora's Mix Vol. 2
+  - `RadioLegionIntermission5Syndicate` for Nora's Mix Vol. 1
+  - `RadioLegionIntermission4Syndicate` for Nora's Choice
+  - `RadioLegionIntermission3Syndicate` for Intermission III
+  - `RadioLegion3Syndicate` for Glassmaker
+  - `RadioLegionIntermission2Syndicate` for Intermission II
+  - `RadioLegion2Syndicate` for The Emissary
+  - `RadioLegionIntermissionSyndicate` for Intermission I
+  - `RadioLegionSyndicate` for The Wolf of Saturn Six
+- `worldState.allTheFissures` can be set to `normal` or `hard` to enable all fissures either in normal or steel path, respectively.
+- `worldState.circuitGameModes` can be set to an array of game modes which will override the otherwise-random pattern in The Circuit. Valid element values are `Survival`, `VoidFlood`, `Excavation`, `Defense`, `Exterminate`, `Assassination`, and `Alchemy`.

UPDATE AND START SERVER.bat

@@ -0,0 +1,33 @@
+@echo off
+
+echo Updating SpaceNinjaServer...
+git fetch --prune
+if %errorlevel% == 0 (
+	git stash
+	git checkout -f origin/main
+
+	if exist static\data\0\ (
+		echo Updating stripped assets...
+		cd static\data\0\
+		git pull
+		cd ..\..\..\
+	)
+
+	echo Updating dependencies...
+	node scripts/raw-precheck.js > NUL
+	if %errorlevel% == 0 (
+		call npm i --omit=dev --omit=optional
+		call npm run raw
+	) else (
+		call npm i --omit=dev
+		call npm run build
+		if %errorlevel% == 0 (
+			call npm run start
+		)
+	)
+	echo SpaceNinjaServer seems to have crashed.
+)
+
+:a
+pause > nul
+goto a

UPDATE AND START SERVER.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+echo "Updating SpaceNinjaServer..."
+git fetch --prune
+if [ $? -eq 0 ]; then
+    git stash
+    git checkout -f origin/main
+
+    if [ -d "static/data/0/" ]; then
+        echo "Updating stripped assets..."
+        cd static/data/0/
+        git pull
+        cd ../../../
+    fi
+
+    echo "Updating dependencies..."
+    node scripts/raw-precheck.js > /dev/null
+    if [ $? -eq 0 ]; then
+        npm i --omit=dev --omit=optional
+        npm run raw
+    else
+        npm i --omit=dev
+        npm run build
+        if [ $? -eq 0 ]; then
+            npm run start
+        fi
+    fi
+    echo "SpaceNinjaServer seems to have crashed."
+fi

config-vanilla.json

@@ -0,0 +1,74 @@
+{
+  "mongodbUrl": "mongodb://127.0.0.1:27017/openWF",
+  "logger": {
+    "files": true,
+    "level": "trace"
+  },
+  "myAddress": "localhost",
+  "bindAddress": "0.0.0.0",
+  "httpPort": 80,
+  "httpsPort": 443,
+  "ircExecutable": null,
+  "ircAddress": null,
+  "hubAddress": null,
+  "nrsAddress": null,
+  "administratorNames": [],
+  "autoCreateAccount": true,
+  "skipTutorial": false,
+  "unlockAllSkins": false,
+  "fullyStockedVendors": false,
+  "skipClanKeyCrafting": false,
+  "unfaithfulBugFixes": {
+    "ignore1999LastRegionPlayed": false,
+    "fixXtraCheeseTimer": false,
+    "useAnniversaryTagForOldGoals": true
+  },
+  "worldState": {
+    "creditBoost": false,
+    "affinityBoost": false,
+    "resourceBoost": false,
+    "tennoLiveRelay": false,
+    "baroTennoConRelay": false,
+    "baroAlwaysAvailable": false,
+    "baroFullyStocked": false,
+    "varziaFullyStocked": false,
+    "wolfHunt": null,
+    "orphixVenom": false,
+    "longShadow": false,
+    "hallowedFlame": false,
+    "anniversary": null,
+    "hallowedNightmares": false,
+    "hallowedNightmaresRewardsOverride": 0,
+    "naberusNightsOverride": null,
+    "proxyRebellion": false,
+    "proxyRebellionRewardsOverride": 0,
+    "voidCorruption2025Week1": false,
+    "voidCorruption2025Week2": false,
+    "voidCorruption2025Week3": false,
+    "voidCorruption2025Week4": false,
+    "qtccAlerts": false,
+    "galleonOfGhouls": 0,
+    "ghoulEmergenceOverride": null,
+    "plagueStarOverride": null,
+    "starDaysOverride": null,
+    "dogDaysOverride": null,
+    "dogDaysRewardsOverride": null,
+    "bellyOfTheBeast": false,
+    "bellyOfTheBeastProgressOverride": 0,
+    "eightClaw": false,
+    "eightClawProgressOverride": 0,
+    "thermiaFracturesOverride": null,
+    "thermiaFracturesProgressOverride": 0,
+    "eidolonOverride": "",
+    "vallisOverride": "",
+    "duviriOverride": "",
+    "nightwaveOverride": "",
+    "allTheFissures": "",
+    "varziaOverride": "",
+    "circuitGameModes": null,
+    "darvoStockMultiplier": 1
+  },
+  "dev": {
+    "keepVendorsExpired": false
+  }
+}

config.json.example

@@ -1,26 +0,0 @@
-{
-  "mongodbUrl": "mongodb://127.0.0.1:27017/openWF_2013",
-  "logger": {
-    "files": true,
-    "level": "trace",
-    "__valid_levels": "fatal, error, warn, info, http, debug, trace"
-  },
-  "myAddress": "localhost",
-  "httpPort": 80,
-  "httpsPort": 443,
-  "autoCreateAccount": true,
-  "skipStoryModeChoice": true,
-  "skipTutorial": true,
-  "skipAllDialogue": true,
-  "unlockAllScans": true,
-  "unlockAllMissions": true,
-  "unlockAllQuests": true,
-  "completeAllQuests": false,
-  "infiniteResources": true,
-  "unlockAllShipFeatures": true,
-  "unlockAllShipDecorations": true,
-  "unlockAllFlavourItems": true,
-  "unlockAllSkins": true,
-  "universalPolarityEverywhere": true,
-  "spoofMasteryRank": -1
-}

docker-compose.yml

@@ -1,24 +1,23 @@
-version: "3.9"
-
 services:
-    mongodb:
-        container_name: mongodb
-        image: mongodb
-        restart: always
-        build:
-            context: .
-            dockerfile: Dockerfile
-            target: base
-        environment:
-            MONGO_INITDB_ROOT_USERNAME: ${DATABASE_USERNAME}
-            MONGO_INITDB_ROOT_PASSWORD: ${DATABASE_PASSWORD}
-        ports:
-            - ${DATABASE_PORT}:${DATABASE_PORT}
-        expose:
-            - "${DATABASE_PORT}"
-        networks:
-            - docker
+    spaceninjaserver:
+        image: openwf/spaceninjaserver:latest
 
-networks:
-    docker:
-        external: true
+        volumes:
+            - ./docker-data/conf:/app/conf
+            - ./docker-data/static-data:/app/static/data
+            - ./docker-data/logs:/app/logs
+        ports:
+            - 80:80
+            - 443:443
+
+        # Normally, the image is fetched from Docker Hub, but you can use the local Dockerfile by removing "image" above and adding this:
+        #build: .
+        # Works best when using `docker-compose up --force-recreate --build`.
+
+        depends_on:
+            - mongodb
+    mongodb:
+        image: docker.io/library/mongo:8.0.0-noble
+        volumes:
+            - ./docker-data/database:/data/db
+        command: mongod --quiet --logpath /dev/null

docker-entrypoint.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -e
+
+if [ ! -f conf/config.json ]; then
+	jq --arg value "mongodb://mongodb:27017/openWF" '.mongodbUrl = $value' /app/config-vanilla.json > /app/conf/config.json
+fi
+
+exec npm run raw -- --configPath conf/config.json

package.json

@@ -4,38 +4,63 @@
   "description": "WF Emulator",
   "main": "index.ts",
   "scripts": {
-    "start": "node --import ./build/src/pathman.js build/src/index.js",
-    "dev": "ts-node-dev --openssl-legacy-provider -r tsconfig-paths/register src/index.ts ",
-    "build": "tsc && copyfiles static/webui/** build",
+    "start": "node --enable-source-maps build/src/index.js",
+    "build": "tsgo --inlineSourceMap && ncp static/webui build/static/webui",
+    "build:tsc": "tsc --incremental --inlineSourceMap && ncp static/webui build/static/webui",
+    "build:dev": "tsgo --inlineSourceMap",
+    "build:dev:tsc": "tsc --incremental --inlineSourceMap",
+    "build-and-start": "npm run build && npm run start",
+    "dev": "node scripts/dev.cjs",
+    "dev:bun": "bun scripts/dev.cjs",
+    "verify": "tsgo --noEmit",
+    "verify:tsc": "tsc --noEmit",
+    "raw": "node scripts/raw-precheck.js && node --experimental-transform-types src/index.ts",
+    "raw:bun": "bun src/index.ts",
     "lint": "eslint --ext .ts .",
+    "lint:ci": "eslint --ext .ts --rule \"prettier/prettier: off\" .",
     "lint:fix": "eslint --fix --ext .ts .",
-    "prettier": "prettier --write ."
+    "prettier": "prettier --write .",
+    "update-translations": "cd scripts && node update-translations.cjs",
+    "fix": "npm run update-translations && npm run prettier"
   },
   "license": "GNU",
+  "type": "module",
   "dependencies": {
-    "copyfiles": "^2.4.1",
-    "express": "^5.0.0-beta.3",
-    "mongoose": "^8.4.5",
-    "warframe-public-export-plus": "^0.4.4",
-    "warframe-riven-info": "^0.1.1",
-    "winston": "^3.13.0",
-    "winston-daily-rotate-file": "^5.0.0"
+    "body-parser": "^2.2.0",
+    "chokidar": "^4.0.3",
+    "crc-32": "^1.2.2",
+    "express": "^5",
+    "json-with-bigint": "^3.4.4",
+    "mongoose": "^8.11.0",
+    "morgan": "^1.10.0",
+    "ncp": "^2.0.0",
+    "undici": "^7.10.0",
+    "warframe-public-export-plus": "^0.5.93",
+    "warframe-riven-info": "^0.1.2",
+    "winston": "^3.17.0",
+    "winston-daily-rotate-file": "^5.0.0",
+    "ws": "^8.18.2"
+  },
+  "optionalDependencies": {
+    "@types/body-parser": "^1.19.6",
+    "@types/express": "^5",
+    "@types/morgan": "^1.9.9",
+    "@types/websocket": "^1.0.10",
+    "@types/ws": "^8.18.1",
+    "@typescript/native-preview": "^7.0.0-dev.20250625.1",
+    "typescript": "^5.7"
   },
   "devDependencies": {
-    "@types/express": "^4.17.20",
-    "@types/morgan": "^1.9.9",
-    "@typescript-eslint/eslint-plugin": "^7.14",
-    "@typescript-eslint/parser": "^7.14",
-    "eslint": "^8.56.0",
-    "eslint-plugin-prettier": "^5.1.3",
-    "morgan": "^1.10.0",
-    "prettier": "^3.3.2",
-    "ts-node-dev": "^2.0.0",
-    "tsconfig-paths": "^4.2.0",
-    "typescript": "^5.5"
+    "@typescript-eslint/eslint-plugin": "^8.28.0",
+    "@typescript-eslint/parser": "^8.28.0",
+    "eslint": "^8",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.2.5",
+    "prettier": "^3.5.3",
+    "tree-kill": "^1.2.2"
   },
   "engines": {
-    "node": ">=18.15.0",
-    "npm": ">=9.5.0"
+    "node": ">=20.18.1"
   }
 }

scripts/dev.cjs

@@ -0,0 +1,81 @@
+/* eslint-disable */
+const { spawn } = require("child_process");
+const chokidar = require("chokidar");
+const kill = require("tree-kill");
+
+let secret = "";
+for (let i = 0; i != 10; ++i) {
+    secret += String.fromCharCode(Math.floor(Math.random() * 26) + 0x41);
+}
+
+const args = [...process.argv].splice(2);
+args.push("--dev");
+args.push("--secret");
+args.push(secret);
+
+const cangoraw = (() => {
+    if (process.versions.bun) {
+        return true;
+    }
+    const [major, minor] = process.versions.node.split(".").map(x => parseInt(x));
+    if (major > 22 || (major == 22 && minor >= 7)) {
+        return true;
+    }
+    return false;
+})();
+
+let buildproc, runproc;
+const spawnopts = { stdio: "inherit", shell: true };
+function run(changedFile) {
+    if (changedFile) {
+        console.log(`Change to ${changedFile} detected`);
+    }
+
+    if (buildproc) {
+        kill(buildproc.pid);
+        buildproc = undefined;
+    }
+    if (runproc) {
+        kill(runproc.pid);
+        runproc = undefined;
+    }
+
+    const thisbuildproc = spawn(
+        [process.versions.bun ? "bun" : "npm", "run", cangoraw ? "verify" : "build:dev"].join(" "),
+        spawnopts
+    );
+    const thisbuildstart = Date.now();
+    buildproc = thisbuildproc;
+    buildproc.on("exit", code => {
+        if (buildproc !== thisbuildproc) {
+            return;
+        }
+        buildproc = undefined;
+        if (code === 0) {
+            console.log(`${cangoraw ? "Verified" : "Built"} in ${Date.now() - thisbuildstart} ms`);
+            runproc = spawn(
+                [
+                    process.versions.bun ? "bun" : "npm",
+                    "run",
+                    cangoraw ? (process.versions.bun ? "raw:bun" : "raw") : "start",
+                    "--",
+                    ...args
+                ].join(" "),
+                spawnopts
+            );
+            runproc.on("exit", () => {
+                runproc = undefined;
+            });
+        }
+    });
+}
+
+run();
+chokidar.watch("src").on("change", run);
+chokidar.watch("static/fixed_responses").on("change", run);
+
+chokidar.watch("static/webui").on("change", async () => {
+    try {
+        await fetch("http://localhost/custom/webuiFileChangeDetected?secret=" + secret);
+    } catch (e) {}
+});

scripts/raw-precheck.js

@@ -0,0 +1,9 @@
+const [major, minor] = process.versions.node.split(".").map(x => parseInt(x));
+if (major > 22 || (major == 22 && minor >= 7)) {
+    // ok
+} else {
+    console.log("Sorry, your Node version is a bit too old for this. You have 2 options:");
+    console.log("- Update Node.js.");
+    console.log("- Use 'npm run build && npm run start'. Optional libraries must be installed for this.");
+    process.exit(1);
+}

scripts/update-translations.cjs

@@ -0,0 +1,47 @@
+// Based on https://onlyg.it/OpenWF/Translations/src/branch/main/update.php
+// Converted via ChatGPT-4o
+
+/* eslint-disable */
+const fs = require("fs");
+
+function extractStrings(content) {
+    const regex = /([a-zA-Z0-9_]+): `([^`]*)`,/g;
+    let matches;
+    const strings = {};
+    while ((matches = regex.exec(content)) !== null) {
+        strings[matches[1]] = matches[2];
+    }
+    return strings;
+}
+
+const source = fs.readFileSync("../static/webui/translations/en.js", "utf8");
+const sourceStrings = extractStrings(source);
+const sourceLines = source.substring(0, source.length - 1).split("\n");
+
+fs.readdirSync("../static/webui/translations").forEach(file => {
+    if (fs.lstatSync(`../static/webui/translations/${file}`).isFile() && file !== "en.js") {
+        const content = fs.readFileSync(`../static/webui/translations/${file}`, "utf8");
+        const targetStrings = extractStrings(content);
+        const contentLines = content.split("\n");
+
+        const fileHandle = fs.openSync(`../static/webui/translations/${file}`, "w");
+        fs.writeSync(fileHandle, contentLines[0] + "\n");
+
+        sourceLines.forEach(line => {
+            const strings = extractStrings(line);
+            if (Object.keys(strings).length > 0) {
+                Object.entries(strings).forEach(([key, value]) => {
+                    if (targetStrings.hasOwnProperty(key) && !targetStrings[key].startsWith("[UNTRANSLATED]")) {
+                        fs.writeSync(fileHandle, `    ${key}: \`${targetStrings[key]}\`,\n`);
+                    } else {
+                        fs.writeSync(fileHandle, `    ${key}: \`[UNTRANSLATED] ${value}\`,\n`);
+                    }
+                });
+            } else {
+                fs.writeSync(fileHandle, line + "\n");
+            }
+        });
+
+        fs.closeSync(fileHandle);
+    }
+});

src/app.ts

@@ -1,65 +1,51 @@
 import express from "express";
 
-import { unknownEndpointHandler } from "@/src/middleware/middleware";
-import { requestLogger } from "@/src/middleware/morgenMiddleware";
-
-import { apiRouter } from "@/src/routes/api";
-//import { testRouter } from "@/src/routes/test";
-import { cacheRouter } from "@/src/routes/cache";
 import bodyParser from "body-parser";
+import { unknownEndpointHandler } from "./middleware/middleware.ts";
+import { requestLogger } from "./middleware/morgenMiddleware.ts";
+import { errorHandler } from "./middleware/errorHandler.ts";
 
-import { steamPacksController } from "@/src/controllers/misc/steamPacksController";
-import { customRouter } from "@/src/routes/custom";
-import { dynamicController } from "@/src/routes/dynamic";
-import { statsRouter } from "@/src/routes/stats";
-import { webuiRouter } from "@/src/routes/webui";
-import { connectDatabase } from "@/src/services/mongoService";
-import { registerLogFileCreationListener } from "@/src/utils/logger";
-import * as zlib from "zlib";
-
-void registerLogFileCreationListener();
-void connectDatabase();
+import { apiRouter } from "./routes/api.ts";
+import { cacheRouter } from "./routes/cache.ts";
+import { customRouter } from "./routes/custom.ts";
+import { dynamicController } from "./routes/dynamic.ts";
+import { payRouter } from "./routes/pay.ts";
+import { statsRouter } from "./routes/stats.ts";
+import { webuiRouter } from "./routes/webui.ts";
 
 const app = express();
 
-app.use(function (req, _res, next) {
-    const buffer: Buffer[] = [];
-    req.on("data", function (chunk: Buffer) {
-        if (chunk !== undefined && chunk.length > 2 && chunk[0] == 0x1f && chunk[1] == 0x8b) {
-            buffer.push(Buffer.from(chunk));
-        }
-    });
+app.use((req, _res, next) => {
+    // 38.5.0 introduced "ezip" for encrypted body blobs and "e" for request verification only (encrypted body blobs with no application data).
+    // The client patch is expected to decrypt it for us but having an unsupported Content-Encoding here would still be an issue for Express, so removing it.
+    if (req.headers["content-encoding"] == "ezip" || req.headers["content-encoding"] == "e") {
+        req.headers["content-encoding"] = undefined;
+    }
 
-    req.on("end", function () {
-        zlib.gunzip(Buffer.concat(buffer), function (_err, dezipped) {
-            if (typeof dezipped != "undefined") {
-                req.body = dezipped.toString("utf-8");
-            }
+    // U18 uses application/x-www-form-urlencoded even tho the data is JSON which Express doesn't like.
+    // U17 sets no Content-Type at all, which Express also doesn't like.
+    if (!req.headers["content-type"] || req.headers["content-type"] == "application/x-www-form-urlencoded") {
+        req.headers["content-type"] = "application/octet-stream";
+    }
 
-            next();
-        });
-    });
+    next();
 });
 
 app.use(bodyParser.raw());
-app.use(express.json());
-app.use(bodyParser.text());
+app.use(express.json({ limit: "4mb" }));
+app.use(bodyParser.text({ limit: "4mb" }));
 app.use(requestLogger);
-//app.use(requestLogger);
 
 app.use("/api", apiRouter);
-//app.use("/test", testRouter);
 app.use("/", cacheRouter);
 app.use("/custom", customRouter);
+app.use("/dynamic", dynamicController);
 app.use("/:id/dynamic", dynamicController);
-
-app.post("/pay/steamPacks.php", steamPacksController);
+app.use("/pay", payRouter);
 app.use("/stats", statsRouter);
-
 app.use("/", webuiRouter);
 
 app.use(unknownEndpointHandler);
-
-//app.use(errorHandler)
+app.use(errorHandler);
 
 export { app };

src/constants/timeConstants.ts

@@ -1,16 +1,21 @@
+export const EPOCH = 1734307200_000; // Monday, Dec 16, 2024 @ 00:00 UTC+0; should logically be the start of winter in 1999 iteration 0
+
 const millisecondsPerSecond = 1000;
 const secondsPerMinute = 60;
 const minutesPerHour = 60;
 const hoursPerDay = 24;
+const daysPerWeek = 7;
 
 const unixSecond = millisecondsPerSecond;
 const unixMinute = secondsPerMinute * millisecondsPerSecond;
 const unixHour = unixMinute * minutesPerHour;
 const unixDay = hoursPerDay * unixHour;
+const unixWeek = daysPerWeek * unixDay;
 
 export const unixTimesInMs = {
     second: unixSecond,
     minute: unixMinute,
     hour: unixHour,
-    day: unixDay
+    day: unixDay,
+    week: unixWeek
 };

src/controllers/api/abandonLibraryDailyTaskController.ts

@@ -0,0 +1,11 @@
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { RequestHandler } from "express";
+
+export const abandonLibraryDailyTaskController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId);
+    inventory.LibraryActiveDailyTaskInfo = undefined;
+    await inventory.save();
+    res.status(200).end();
+};

src/controllers/api/abortDojoComponentController.ts

@@ -0,0 +1,47 @@
+import {
+    getDojoClient,
+    getGuildForRequestEx,
+    hasAccessToDojo,
+    hasGuildPermission,
+    removeDojoDeco,
+    removeDojoRoom
+} from "../../services/guildService.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { GuildPermission } from "../../types/guildTypes.ts";
+import type { RequestHandler } from "express";
+
+export const abortDojoComponentController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "GuildId LevelKeys");
+    const guild = await getGuildForRequestEx(req, inventory);
+    const request = JSON.parse(String(req.body)) as IAbortDojoComponentRequest;
+
+    if (
+        !hasAccessToDojo(inventory) ||
+        !(await hasGuildPermission(
+            guild,
+            accountId,
+            request.DecoId ? GuildPermission.Decorator : GuildPermission.Architect
+        ))
+    ) {
+        res.json({ DojoRequestStatus: -1 });
+        return;
+    }
+
+    if (request.DecoId) {
+        removeDojoDeco(guild, request.ComponentId, request.DecoId);
+        await guild.save();
+        res.json(await getDojoClient(guild, 0, request.ComponentId));
+    } else {
+        await removeDojoRoom(guild, request.ComponentId);
+        await guild.save();
+        res.json(await getDojoClient(guild, 0));
+    }
+};
+
+interface IAbortDojoComponentRequest {
+    DecoType?: string;
+    ComponentId: string;
+    DecoId?: string;
+}

src/controllers/api/abortDojoComponentDestructionController.ts

@@ -0,0 +1,26 @@
+import {
+    getDojoClient,
+    getGuildForRequestEx,
+    hasAccessToDojo,
+    hasGuildPermission
+} from "../../services/guildService.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { GuildPermission } from "../../types/guildTypes.ts";
+import type { RequestHandler } from "express";
+
+export const abortDojoComponentDestructionController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "GuildId LevelKeys");
+    const guild = await getGuildForRequestEx(req, inventory);
+    if (!hasAccessToDojo(inventory) || !(await hasGuildPermission(guild, accountId, GuildPermission.Architect))) {
+        res.json({ DojoRequestStatus: -1 });
+        return;
+    }
+    const componentId = req.query.componentId as string;
+
+    guild.DojoComponents.id(componentId)!.DestructionTime = undefined;
+
+    await guild.save();
+    res.json(await getDojoClient(guild, 0, componentId));
+};

src/controllers/api/activateRandomModController.ts

@@ -0,0 +1,46 @@
+import { toOid } from "../../helpers/inventoryHelpers.ts";
+import {
+    createVeiledRivenFingerprint,
+    createUnveiledRivenFingerprint,
+    rivenRawToRealWeighted
+} from "../../helpers/rivenHelper.ts";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { addMods, getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { getRandomElement } from "../../services/rngService.ts";
+import type { RequestHandler } from "express";
+import { ExportUpgrades } from "warframe-public-export-plus";
+
+export const activateRandomModController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "RawUpgrades Upgrades instantFinishRivenChallenge");
+    const request = getJSONfromString<IActiveRandomModRequest>(String(req.body));
+    addMods(inventory, [
+        {
+            ItemType: request.ItemType,
+            ItemCount: -1
+        }
+    ]);
+    const rivenType = getRandomElement(rivenRawToRealWeighted[request.ItemType])!;
+    const fingerprint = inventory.instantFinishRivenChallenge
+        ? createUnveiledRivenFingerprint(ExportUpgrades[rivenType])
+        : createVeiledRivenFingerprint(ExportUpgrades[rivenType]);
+    const upgradeIndex =
+        inventory.Upgrades.push({
+            ItemType: rivenType,
+            UpgradeFingerprint: JSON.stringify(fingerprint)
+        }) - 1;
+    await inventory.save();
+    // For some reason, in this response, the UpgradeFingerprint is simply a nested object and not a string
+    res.json({
+        NewMod: {
+            UpgradeFingerprint: fingerprint,
+            ItemType: rivenType,
+            ItemId: toOid(inventory.Upgrades[upgradeIndex]._id)
+        }
+    });
+};
+
+interface IActiveRandomModRequest {
+    ItemType: string;
+}

src/controllers/api/addFriendController.ts

@@ -0,0 +1,60 @@
+import { toOid } from "../../helpers/inventoryHelpers.ts";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { Friendship } from "../../models/friendModel.ts";
+import { addAccountDataToFriendInfo, addInventoryDataToFriendInfo } from "../../services/friendService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { IFriendInfo } from "../../types/friendTypes.ts";
+import type { RequestHandler } from "express";
+
+export const addFriendController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const payload = getJSONfromString<IAddFriendRequest>(String(req.body));
+    const promises: Promise<void>[] = [];
+    const newFriends: IFriendInfo[] = [];
+    if (payload.friend == "all") {
+        const [internalFriendships, externalFriendships] = await Promise.all([
+            Friendship.find({ owner: accountId }, "friend"),
+            Friendship.find({ friend: accountId }, "owner")
+        ]);
+        for (const externalFriendship of externalFriendships) {
+            if (!internalFriendships.find(x => x.friend.equals(externalFriendship.owner))) {
+                promises.push(
+                    Friendship.insertOne({
+                        owner: accountId,
+                        friend: externalFriendship.owner,
+                        Note: externalFriendship.Note // TOVERIFY: Should the note be copied when accepting a friend request?
+                    }) as unknown as Promise<void>
+                );
+                newFriends.push({
+                    _id: toOid(externalFriendship.owner)
+                });
+            }
+        }
+    } else {
+        const externalFriendship = await Friendship.findOne({ owner: payload.friend, friend: accountId }, "Note");
+        if (externalFriendship) {
+            promises.push(
+                Friendship.insertOne({
+                    owner: accountId,
+                    friend: payload.friend,
+                    Note: externalFriendship.Note
+                }) as unknown as Promise<void>
+            );
+            newFriends.push({
+                _id: { $oid: payload.friend }
+            });
+        }
+    }
+    for (const newFriend of newFriends) {
+        promises.push(addAccountDataToFriendInfo(newFriend));
+        promises.push(addInventoryDataToFriendInfo(newFriend));
+    }
+    await Promise.all(promises);
+    res.json({
+        Friends: newFriends
+    });
+};
+
+interface IAddFriendRequest {
+    friend: string; // oid or "all" in which case all=1 is also a query parameter
+}

src/controllers/api/addFriendImageController.ts

@@ -1,17 +1,40 @@
-import { RequestHandler } from "express";
-import { getJSONfromString } from "@/src/helpers/stringHelpers";
-import { IUpdateGlyphRequest } from "@/src/types/requestTypes";
-import { getAccountIdForRequest } from "@/src/services/loginService";
-import { getInventory } from "@/src/services/inventoryService";
+import type { RequestHandler } from "express";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { Inventory } from "../../models/inventoryModels/inventoryModel.ts";
 
-// eslint-disable-next-line @typescript-eslint/no-misused-promises
-const addFriendImageController: RequestHandler = async (req, res) => {
+export const addFriendImageGetController: RequestHandler = async (req, res) => {
     const accountId = await getAccountIdForRequest(req);
-    const json = getJSONfromString(String(req.body)) as IUpdateGlyphRequest;
-    const inventory = await getInventory(accountId);
-    inventory.ActiveAvatarImageType = json.AvatarImageType;
-    await inventory.save();
+
+    await Inventory.updateOne(
+        {
+            accountOwnerId: accountId
+        },
+        {
+            ActiveAvatarImageType: String(req.query.avatarImageType)
+        }
+    );
+
     res.json({});
 };
 
-export { addFriendImageController };
+export const addFriendImagePostController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const json = getJSONfromString<IUpdateGlyphRequest>(String(req.body));
+
+    await Inventory.updateOne(
+        {
+            accountOwnerId: accountId
+        },
+        {
+            ActiveAvatarImageType: json.AvatarImageType
+        }
+    );
+
+    res.json({});
+};
+
+interface IUpdateGlyphRequest {
+    AvatarImageType: string;
+    AvatarImage: string;
+}

src/controllers/api/addIgnoredUserController.ts

@@ -0,0 +1,30 @@
+import { toOid } from "../../helpers/inventoryHelpers.ts";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { Account, Ignore } from "../../models/loginModel.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { IFriendInfo } from "../../types/friendTypes.ts";
+import type { RequestHandler } from "express";
+
+export const addIgnoredUserController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const data = getJSONfromString<IAddIgnoredUserRequest>(String(req.body));
+    const ignoreeAccount = await Account.findOne(
+        { DisplayName: data.playerName.substring(0, data.playerName.length - 1) },
+        "_id"
+    );
+    if (ignoreeAccount) {
+        await Ignore.create({ ignorer: accountId, ignoree: ignoreeAccount._id });
+        res.json({
+            Ignored: {
+                _id: toOid(ignoreeAccount._id),
+                DisplayName: data.playerName
+            } satisfies IFriendInfo
+        });
+    } else {
+        res.status(400).end();
+    }
+};
+
+interface IAddIgnoredUserRequest {
+    playerName: string;
+}

src/controllers/api/addPendingFriendController.ts

@@ -0,0 +1,52 @@
+import { toMongoDate, toOid } from "../../helpers/inventoryHelpers.ts";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { Friendship } from "../../models/friendModel.ts";
+import { Account } from "../../models/loginModel.ts";
+import { addInventoryDataToFriendInfo, areFriendsOfFriends } from "../../services/friendService.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { IFriendInfo } from "../../types/friendTypes.ts";
+import type { RequestHandler } from "express";
+
+export const addPendingFriendController: RequestHandler = async (req, res) => {
+    const payload = getJSONfromString<IAddPendingFriendRequest>(String(req.body));
+
+    const account = await Account.findOne({ DisplayName: payload.friend });
+    if (!account) {
+        res.status(400).end();
+        return;
+    }
+
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(account._id.toString(), "Settings");
+    if (
+        inventory.Settings?.FriendInvRestriction == "GIFT_MODE_NONE" ||
+        (inventory.Settings?.FriendInvRestriction == "GIFT_MODE_FRIENDS" &&
+            !(await areFriendsOfFriends(account._id, accountId)))
+    ) {
+        res.status(400).send("Friend Invite Restriction");
+        return;
+    }
+
+    await Friendship.insertOne({
+        owner: accountId,
+        friend: account._id,
+        Note: payload.message
+    });
+
+    const friendInfo: IFriendInfo = {
+        _id: toOid(account._id),
+        DisplayName: account.DisplayName,
+        LastLogin: toMongoDate(account.LastLogin),
+        Note: payload.message
+    };
+    await addInventoryDataToFriendInfo(friendInfo);
+    res.json({
+        Friend: friendInfo
+    });
+};
+
+interface IAddPendingFriendRequest {
+    friend: string;
+    message: string;
+}

src/controllers/api/addToAllianceController.ts

@@ -0,0 +1,117 @@
+import { getJSONfromString, regexEscape } from "../../helpers/stringHelpers.ts";
+import { Alliance, AllianceMember, Guild, GuildMember } from "../../models/guildModel.ts";
+import { createMessage } from "../../services/inboxService.ts";
+import { getEffectiveAvatarImageType, getInventory } from "../../services/inventoryService.ts";
+import { getAccountForRequest, getSuffixedName } from "../../services/loginService.ts";
+import { GuildPermission } from "../../types/guildTypes.ts";
+import { logger } from "../../utils/logger.ts";
+import type { RequestHandler } from "express";
+import { ExportFlavour } from "warframe-public-export-plus";
+
+export const addToAllianceController: RequestHandler = async (req, res) => {
+    // Check requester is a warlord in their guild
+    const account = await getAccountForRequest(req);
+    const guildMember = (await GuildMember.findOne({ accountId: account._id, status: 0 }))!;
+    if (guildMember.rank > 1) {
+        res.status(400).json({ Error: 104 });
+        return;
+    }
+
+    // Check guild has invite permissions in the alliance
+    const allianceMember = (await AllianceMember.findOne({
+        allianceId: req.query.allianceId,
+        guildId: guildMember.guildId
+    }))!;
+    if (!(allianceMember.Permissions & GuildPermission.Recruiter)) {
+        res.status(400).json({ Error: 104 });
+        return;
+    }
+
+    // Find clan to invite
+    const payload = getJSONfromString<IAddToAllianceRequest>(String(req.body));
+    const guilds = await Guild.find(
+        {
+            Name:
+                payload.clanName.indexOf("#") == -1
+                    ? new RegExp("^" + regexEscape(payload.clanName) + "#...$")
+                    : payload.clanName
+        },
+        "Name"
+    );
+    if (guilds.length == 0) {
+        res.status(400).json({ Error: 101 });
+        return;
+    }
+    if (guilds.length > 1) {
+        const choices: IGuildChoice[] = [];
+        for (const guild of guilds) {
+            choices.push({
+                OriginalPlatform: 0,
+                Name: guild.Name
+            });
+        }
+        res.json(choices);
+        return;
+    }
+
+    // Add clan as a pending alliance member
+    try {
+        await AllianceMember.insertOne({
+            allianceId: req.query.allianceId,
+            guildId: guilds[0]._id,
+            Pending: true,
+            Permissions: 0
+        });
+    } catch (e) {
+        logger.debug(`alliance invite failed due to ${String(e)}`);
+        res.status(400).json({ Error: 102 });
+        return;
+    }
+
+    // Send inbox message to founding warlord
+    // TOVERIFY: Should other warlords get this as well?
+    // TOVERIFY: Who/what should the sender be?
+    // TOVERIFY: Should this message be highPriority?
+    const invitedClanOwnerMember = (await GuildMember.findOne({ guildId: guilds[0]._id, rank: 0 }))!;
+    const senderInventory = await getInventory(account._id.toString(), "ActiveAvatarImageType");
+    const senderGuild = (await Guild.findById(allianceMember.guildId, "Name"))!;
+    const alliance = (await Alliance.findById(req.query.allianceId as string, "Name"))!;
+    await createMessage(invitedClanOwnerMember.accountId, [
+        {
+            sndr: getSuffixedName(account),
+            msg: "/Lotus/Language/Menu/Mailbox_AllianceInvite_Body",
+            arg: [
+                {
+                    Key: "THEIR_CLAN",
+                    Tag: senderGuild.Name
+                },
+                {
+                    Key: "CLAN",
+                    Tag: guilds[0].Name
+                },
+                {
+                    Key: "ALLIANCE",
+                    Tag: alliance.Name
+                }
+            ],
+            sub: "/Lotus/Language/Menu/Mailbox_AllianceInvite_Title",
+            icon: ExportFlavour[getEffectiveAvatarImageType(senderInventory)].icon,
+            contextInfo: alliance._id.toString(),
+            highPriority: true,
+            acceptAction: "ALLIANCE_INVITE",
+            declineAction: "ALLIANCE_INVITE",
+            hasAccountAction: true
+        }
+    ]);
+
+    res.end();
+};
+
+interface IAddToAllianceRequest {
+    clanName: string;
+}
+
+interface IGuildChoice {
+    OriginalPlatform: number;
+    Name: string;
+}

src/controllers/api/addToGuildController.ts

@@ -0,0 +1,112 @@
+import { toMongoDate } from "../../helpers/inventoryHelpers.ts";
+import { Guild, GuildMember } from "../../models/guildModel.ts";
+import { Account } from "../../models/loginModel.ts";
+import { addInventoryDataToFriendInfo, areFriends } from "../../services/friendService.ts";
+import { hasGuildPermission } from "../../services/guildService.ts";
+import { createMessage } from "../../services/inboxService.ts";
+import { getEffectiveAvatarImageType, getInventory } from "../../services/inventoryService.ts";
+import { getAccountForRequest, getAccountIdForRequest, getSuffixedName } from "../../services/loginService.ts";
+import type { IOid } from "../../types/commonTypes.ts";
+import type { IGuildMemberClient } from "../../types/guildTypes.ts";
+import { GuildPermission } from "../../types/guildTypes.ts";
+import { logger } from "../../utils/logger.ts";
+import type { RequestHandler } from "express";
+import { ExportFlavour } from "warframe-public-export-plus";
+
+export const addToGuildController: RequestHandler = async (req, res) => {
+    const payload = JSON.parse(String(req.body)) as IAddToGuildRequest;
+
+    if ("UserName" in payload) {
+        // Clan recruiter sending an invite
+
+        const account = await Account.findOne({ DisplayName: payload.UserName });
+        if (!account) {
+            res.status(400).json("Username does not exist");
+            return;
+        }
+
+        const senderAccount = await getAccountForRequest(req);
+        const inventory = await getInventory(account._id.toString(), "Settings");
+        if (
+            inventory.Settings?.GuildInvRestriction == "GIFT_MODE_NONE" ||
+            (inventory.Settings?.GuildInvRestriction == "GIFT_MODE_FRIENDS" &&
+                !(await areFriends(account._id, senderAccount._id)))
+        ) {
+            res.status(400).json("Invite restricted");
+            return;
+        }
+
+        const guild = (await Guild.findById(payload.GuildId.$oid, "Name Ranks"))!;
+        if (!(await hasGuildPermission(guild, senderAccount._id.toString(), GuildPermission.Recruiter))) {
+            res.status(400).json("Invalid permission");
+        }
+
+        try {
+            await GuildMember.insertOne({
+                accountId: account._id,
+                guildId: payload.GuildId.$oid,
+                status: 2 // outgoing invite
+            });
+        } catch (e) {
+            logger.debug(`guild invite failed due to ${String(e)}`);
+            res.status(400).json("User already invited to clan");
+            return;
+        }
+
+        const senderInventory = await getInventory(senderAccount._id.toString(), "ActiveAvatarImageType");
+        await createMessage(account._id, [
+            {
+                sndr: getSuffixedName(senderAccount),
+                msg: "/Lotus/Language/Menu/Mailbox_ClanInvite_Body",
+                arg: [
+                    {
+                        Key: "clan",
+                        Tag: guild.Name
+                    }
+                ],
+                sub: "/Lotus/Language/Menu/Mailbox_ClanInvite_Title",
+                icon: ExportFlavour[getEffectiveAvatarImageType(senderInventory)].icon,
+                contextInfo: payload.GuildId.$oid,
+                highPriority: true,
+                acceptAction: "GUILD_INVITE",
+                declineAction: "GUILD_INVITE",
+                hasAccountAction: true
+            }
+        ]);
+
+        const member: IGuildMemberClient = {
+            _id: { $oid: account._id.toString() },
+            DisplayName: account.DisplayName,
+            LastLogin: toMongoDate(account.LastLogin),
+            Rank: 7,
+            Status: 2
+        };
+        await addInventoryDataToFriendInfo(member);
+        res.json({ NewMember: member });
+    } else if ("RequestMsg" in payload) {
+        // Player applying to join a clan
+        const accountId = await getAccountIdForRequest(req);
+        try {
+            await GuildMember.insertOne({
+                accountId,
+                guildId: payload.GuildId.$oid,
+                status: 1, // incoming invite
+                RequestMsg: payload.RequestMsg,
+                RequestExpiry: new Date(Date.now() + 14 * 86400 * 1000) // TOVERIFY: I can't find any good information about this with regards to live, but 2 weeks seem reasonable.
+            });
+        } catch (e) {
+            logger.debug(`guild invite failed due to ${String(e)}`);
+            res.status(400).send("Already requested");
+        }
+        res.end();
+    } else {
+        logger.error(`data provided to ${req.path}: ${String(req.body)}`);
+        res.status(400).end();
+    }
+};
+
+interface IAddToGuildRequest {
+    UserName?: string;
+    GuildId: IOid;
+    RequestMsg?: string;
+}

src/controllers/api/adoptPetController.ts

@@ -0,0 +1,27 @@
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { RequestHandler } from "express";
+
+export const adoptPetController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "KubrowPets");
+    const data = getJSONfromString<IAdoptPetRequest>(String(req.body));
+    const details = inventory.KubrowPets.id(data.petId)!.Details!;
+    details.Name = data.name;
+    await inventory.save();
+    res.json({
+        petId: data.petId,
+        newName: data.name
+    } satisfies IAdoptPetResponse);
+};
+
+interface IAdoptPetRequest {
+    petId: string;
+    name: string;
+}
+
+interface IAdoptPetResponse {
+    petId: string;
+    newName: string;
+}

src/controllers/api/apartmentController.ts

@@ -0,0 +1,22 @@
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { getPersonalRooms } from "../../services/personalRoomsService.ts";
+import type { RequestHandler } from "express";
+
+export const apartmentController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const personalRooms = await getPersonalRooms(accountId, "Apartment");
+    const response: IApartmentResponse = {};
+    if (req.query.backdrop !== undefined) {
+        response.NewBackdropItem = personalRooms.Apartment.VideoWallBackdrop = req.query.backdrop as string;
+    }
+    if (req.query.soundscape !== undefined) {
+        response.NewSoundscapeItem = personalRooms.Apartment.Soundscape = req.query.soundscape as string;
+    }
+    await personalRooms.save();
+    res.json(response);
+};
+
+interface IApartmentResponse {
+    NewBackdropItem?: string;
+    NewSoundscapeItem?: string;
+}

src/controllers/api/arcaneCommonController.ts

@@ -0,0 +1,76 @@
+import type { RequestHandler } from "express";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { getInventory, addMods } from "../../services/inventoryService.ts";
+import type { IOid } from "../../types/commonTypes.ts";
+
+export const arcaneCommonController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const json = getJSONfromString<IArcaneCommonRequest>(String(req.body));
+    const inventory = await getInventory(accountId);
+    const upgrade = inventory.Upgrades.id(json.arcane.ItemId.$oid);
+    if (json.newRank == -1) {
+        // Break down request?
+        if (!upgrade || !upgrade.UpgradeFingerprint) {
+            throw new Error(`Failed to find upgrade with OID ${json.arcane.ItemId.$oid}`);
+        }
+
+        // Remove Upgrade
+        inventory.Upgrades.pull({ _id: json.arcane.ItemId.$oid });
+
+        // Add RawUpgrades
+        const numRawUpgradesToGive = arcaneLevelCounts[(JSON.parse(upgrade.UpgradeFingerprint) as { lvl: number }).lvl];
+        addMods(inventory, [
+            {
+                ItemType: json.arcane.ItemType,
+                ItemCount: numRawUpgradesToGive
+            }
+        ]);
+
+        res.json({ upgradeId: json.arcane.ItemId.$oid, numConsumed: numRawUpgradesToGive });
+    } else {
+        // Upgrade request?
+        let numConsumed = arcaneLevelCounts[json.newRank];
+        let upgradeId = json.arcane.ItemId.$oid;
+        if (upgrade) {
+            // Have an existing Upgrade item?
+            if (upgrade.UpgradeFingerprint) {
+                const existingLevel = (JSON.parse(upgrade.UpgradeFingerprint) as { lvl: number }).lvl;
+                numConsumed -= arcaneLevelCounts[existingLevel];
+            }
+            upgrade.UpgradeFingerprint = JSON.stringify({ lvl: json.newRank });
+        } else {
+            const newLength = inventory.Upgrades.push({
+                ItemType: json.arcane.ItemType,
+                UpgradeFingerprint: JSON.stringify({ lvl: json.newRank })
+            });
+            upgradeId = inventory.Upgrades[newLength - 1]._id.toString();
+        }
+
+        // Remove RawUpgrades
+        addMods(inventory, [
+            {
+                ItemType: json.arcane.ItemType,
+                ItemCount: numConsumed * -1
+            }
+        ]);
+
+        res.json({ newLevel: json.newRank, numConsumed, upgradeId });
+    }
+    await inventory.save();
+};
+
+const arcaneLevelCounts = [0, 3, 6, 10, 15, 21];
+
+interface IArcaneCommonRequest {
+    arcane: {
+        ItemType: string;
+        ItemId: IOid;
+        FromSKU: boolean;
+        UpgradeFingerprint: string;
+        PendingRerollFingerprint: string;
+        ItemCount: number;
+        LastAdded: IOid;
+    };
+    newRank: number;
+}

src/controllers/api/archonFusionController.ts

@@ -0,0 +1,51 @@
+import type { RequestHandler } from "express";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { addMiscItems, getInventory } from "../../services/inventoryService.ts";
+import type { IMiscItem } from "../../types/inventoryTypes/inventoryTypes.ts";
+import { colorToShard, combineColors, shardToColor } from "../../helpers/shardHelper.ts";
+
+export const archonFusionController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const request = JSON.parse(String(req.body)) as IArchonFusionRequest;
+    const inventory = await getInventory(accountId);
+    request.Consumed.forEach(x => {
+        x.ItemCount *= -1;
+    });
+    addMiscItems(inventory, request.Consumed);
+    const newArchons: IMiscItem[] = [];
+    switch (request.FusionType) {
+        case "AFT_ASCENT":
+            newArchons.push({
+                ItemType: request.Consumed[0].ItemType + "Mythic",
+                ItemCount: 1
+            });
+            break;
+
+        case "AFT_COALESCENT":
+            newArchons.push({
+                ItemType:
+                    colorToShard[
+                        combineColors(
+                            shardToColor[request.Consumed[0].ItemType],
+                            shardToColor[request.Consumed[1].ItemType]
+                        )
+                    ],
+                ItemCount: 1
+            });
+            break;
+
+        default:
+            throw new Error(`unknown archon fusion type: ${request.FusionType}`);
+    }
+    addMiscItems(inventory, newArchons);
+    await inventory.save();
+    res.json({
+        NewArchons: newArchons
+    });
+};
+
+interface IArchonFusionRequest {
+    Consumed: IMiscItem[];
+    FusionType: string;
+    StatResultType: "SRT_NEW_STAT"; // ???
+}

src/controllers/api/artifactTransmutationController.ts

@@ -0,0 +1,169 @@
+import { fromOid, toOid } from "../../helpers/inventoryHelpers.ts";
+import { createVeiledRivenFingerprint, rivenRawToRealWeighted } from "../../helpers/rivenHelper.ts";
+import { addMiscItems, addMods, getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { getRandomElement, getRandomWeightedReward, getRandomWeightedRewardUc } from "../../services/rngService.ts";
+import type { IUpgradeFromClient } from "../../types/inventoryTypes/inventoryTypes.ts";
+import type { RequestHandler } from "express";
+import type { TRarity } from "warframe-public-export-plus";
+import { ExportBoosterPacks, ExportUpgrades } from "warframe-public-export-plus";
+
+export const artifactTransmutationController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId);
+    const payload = JSON.parse(String(req.body)) as IArtifactTransmutationRequest;
+
+    inventory.RegularCredits -= payload.Cost;
+    inventory.FusionPoints -= payload.FusionPointCost;
+
+    if (payload.RivenTransmute) {
+        addMiscItems(inventory, [
+            {
+                ItemType: "/Lotus/Types/Gameplay/Eidolon/Resources/SentientSecretItem",
+                ItemCount: -1
+            }
+        ]);
+
+        payload.Consumed.forEach(upgrade => {
+            inventory.Upgrades.pull({ _id: fromOid(upgrade.ItemId) });
+        });
+
+        const rawRivenType = getRandomRawRivenType();
+        const rivenType = getRandomElement(rivenRawToRealWeighted[rawRivenType])!;
+        const fingerprint = createVeiledRivenFingerprint(ExportUpgrades[rivenType]);
+
+        const upgradeIndex =
+            inventory.Upgrades.push({
+                ItemType: rivenType,
+                UpgradeFingerprint: JSON.stringify(fingerprint)
+            }) - 1;
+        await inventory.save();
+        res.json({
+            NewMods: [
+                {
+                    ItemId: toOid(inventory.Upgrades[upgradeIndex]._id),
+                    ItemType: rivenType,
+                    UpgradeFingerprint: fingerprint
+                }
+            ]
+        });
+    } else {
+        const counts: Record<TRarity, number> = {
+            COMMON: 0,
+            UNCOMMON: 0,
+            RARE: 0,
+            LEGENDARY: 0
+        };
+        let forcedPolarity: string | undefined;
+        payload.Consumed.forEach(upgrade => {
+            const meta = ExportUpgrades[upgrade.ItemType];
+            counts[meta.rarity] += upgrade.ItemCount;
+            if (fromOid(upgrade.ItemId) != "000000000000000000000000") {
+                inventory.Upgrades.pull({ _id: fromOid(upgrade.ItemId) });
+            } else {
+                addMods(inventory, [
+                    {
+                        ItemType: upgrade.ItemType,
+                        ItemCount: upgrade.ItemCount * -1
+                    }
+                ]);
+            }
+            if (upgrade.ItemType == "/Lotus/Upgrades/Mods/TransmuteCores/AttackTransmuteCore") {
+                forcedPolarity = "AP_ATTACK";
+            } else if (upgrade.ItemType == "/Lotus/Upgrades/Mods/TransmuteCores/DefenseTransmuteCore") {
+                forcedPolarity = "AP_DEFENSE";
+            } else if (upgrade.ItemType == "/Lotus/Upgrades/Mods/TransmuteCores/TacticTransmuteCore") {
+                forcedPolarity = "AP_TACTIC";
+            }
+        });
+
+        let newModType: string | undefined;
+        for (const specialModSet of specialModSets) {
+            if (specialModSet.indexOf(payload.Consumed[0].ItemType) != -1) {
+                newModType = getRandomElement(specialModSet);
+                break;
+            }
+        }
+
+        if (!newModType) {
+            // Based on the table on https://wiki.warframe.com/w/Transmutation
+            const weights: Record<TRarity, number> = {
+                COMMON: counts.COMMON * 95 + counts.UNCOMMON * 15 + counts.RARE * 4,
+                UNCOMMON: counts.COMMON * 4 + counts.UNCOMMON * 80 + counts.RARE * 10,
+                RARE: counts.COMMON * 1 + counts.UNCOMMON * 5 + counts.RARE * 50,
+                LEGENDARY: 0
+            };
+
+            const options: { uniqueName: string; rarity: TRarity }[] = [];
+            Object.entries(ExportUpgrades).forEach(([uniqueName, upgrade]) => {
+                if (upgrade.canBeTransmutation && (!forcedPolarity || upgrade.polarity == forcedPolarity)) {
+                    options.push({ uniqueName, rarity: upgrade.rarity });
+                }
+            });
+
+            newModType = getRandomWeightedReward(options, weights)!.uniqueName;
+        }
+
+        addMods(inventory, [
+            {
+                ItemType: newModType,
+                ItemCount: 1
+            }
+        ]);
+
+        await inventory.save();
+        res.json({
+            NewMods: [
+                {
+                    ItemType: newModType,
+                    ItemCount: 1
+                }
+            ]
+        });
+    }
+};
+
+const getRandomRawRivenType = (): string => {
+    const pack = ExportBoosterPacks["/Lotus/Types/BoosterPacks/CalendarRivenPack"];
+    return getRandomWeightedRewardUc(pack.components, pack.rarityWeightsPerRoll[0])!.Item;
+};
+
+interface IArtifactTransmutationRequest {
+    Upgrade: IUpgradeFromClient;
+    LevelDiff: number;
+    Consumed: IUpgradeFromClient[];
+    Cost: number;
+    FusionPointCost: number;
+    RivenTransmute?: boolean;
+}
+
+const specialModSets: string[][] = [
+    [
+        "/Lotus/Upgrades/Mods/Immortal/ImmortalOneMod",
+        "/Lotus/Upgrades/Mods/Immortal/ImmortalTwoMod",
+        "/Lotus/Upgrades/Mods/Immortal/ImmortalThreeMod",
+        "/Lotus/Upgrades/Mods/Immortal/ImmortalFourMod",
+        "/Lotus/Upgrades/Mods/Immortal/ImmortalFiveMod",
+        "/Lotus/Upgrades/Mods/Immortal/ImmortalSixMod",
+        "/Lotus/Upgrades/Mods/Immortal/ImmortalSevenMod",
+        "/Lotus/Upgrades/Mods/Immortal/ImmortalEightMod",
+        "/Lotus/Upgrades/Mods/Immortal/ImmortalWildcardMod"
+    ],
+    [
+        "/Lotus/Upgrades/Mods/Immortal/AntivirusOneMod",
+        "/Lotus/Upgrades/Mods/Immortal/AntivirusTwoMod",
+        "/Lotus/Upgrades/Mods/Immortal/AntivirusThreeMod",
+        "/Lotus/Upgrades/Mods/Immortal/AntivirusFourMod",
+        "/Lotus/Upgrades/Mods/Immortal/AntivirusFiveMod",
+        "/Lotus/Upgrades/Mods/Immortal/AntivirusSixMod",
+        "/Lotus/Upgrades/Mods/Immortal/AntivirusSevenMod",
+        "/Lotus/Upgrades/Mods/Immortal/AntivirusEightMod"
+    ],
+    [
+        "/Lotus/Upgrades/Mods/DataSpike/Potency/GainAntivirusAndSpeedOnUseMod",
+        "/Lotus/Upgrades/Mods/DataSpike/Potency/GainAntivirusAndWeaponDamageOnUseMod",
+        "/Lotus/Upgrades/Mods/DataSpike/Potency/GainAntivirusLargeOnSingleUseMod",
+        "/Lotus/Upgrades/Mods/DataSpike/Potency/GainAntivirusOnUseMod",
+        "/Lotus/Upgrades/Mods/DataSpike/Potency/GainAntivirusSmallOnSingleUseMod"
+    ]
+];

src/controllers/api/artifactsController.ts

@@ -1,22 +1,70 @@
-import { getJSONfromString } from "@/src/helpers/stringHelpers";
-import { getAccountIdForRequest } from "@/src/services/loginService";
-import { upgradeMod } from "@/src/services/inventoryService";
-import { IArtifactsRequest } from "@/src/types/requestTypes";
-import { RequestHandler } from "express";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { RequestHandler } from "express";
+import type { IInventoryClient, IUpgradeClient } from "../../types/inventoryTypes/inventoryTypes.ts";
+import { addMods, getInventory } from "../../services/inventoryService.ts";
+import { broadcastInventoryUpdate } from "../../services/wsService.ts";
 
-// eslint-disable-next-line @typescript-eslint/no-misused-promises
-const artifactsController: RequestHandler = async (req, res) => {
+export const artifactsController: RequestHandler = async (req, res) => {
     const accountId = await getAccountIdForRequest(req);
+    const artifactsData = getJSONfromString<IArtifactsRequest>(String(req.body));
 
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call
-        const artifactsData = getJSONfromString(req.body.toString()) as IArtifactsRequest;
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        const upgradeModId = await upgradeMod(artifactsData, accountId);
-        res.send(upgradeModId);
-    } catch (err) {
-        console.error("Error parsing JSON data:", err);
+    const { Upgrade, LevelDiff, Cost, FusionPointCost } = artifactsData;
+
+    const inventory = await getInventory(accountId);
+    const { Upgrades } = inventory;
+    const { ItemType, UpgradeFingerprint, ItemId } = Upgrade;
+
+    const safeUpgradeFingerprint = UpgradeFingerprint || '{"lvl":0}';
+    const parsedUpgradeFingerprint = JSON.parse(safeUpgradeFingerprint) as { lvl: number };
+    parsedUpgradeFingerprint.lvl += LevelDiff;
+    const stringifiedUpgradeFingerprint = JSON.stringify(parsedUpgradeFingerprint);
+
+    let itemIndex = Upgrades.findIndex(upgrade => upgrade._id.equals(ItemId.$oid));
+
+    if (itemIndex !== -1) {
+        Upgrades[itemIndex].UpgradeFingerprint = stringifiedUpgradeFingerprint;
+    } else {
+        itemIndex =
+            Upgrades.push({
+                UpgradeFingerprint: stringifiedUpgradeFingerprint,
+                ItemType
+            }) - 1;
+
+        addMods(inventory, [{ ItemType, ItemCount: -1 }]);
     }
+
+    if (!inventory.infiniteCredits) {
+        inventory.RegularCredits -= Cost;
+    }
+    if (!inventory.infiniteEndo) {
+        inventory.FusionPoints -= FusionPointCost;
+    }
+
+    if (artifactsData.LegendaryFusion) {
+        addMods(inventory, [
+            {
+                ItemType: "/Lotus/Upgrades/Mods/Fusers/LegendaryModFuser",
+                ItemCount: -1
+            }
+        ]);
+    }
+
+    const changedInventory = await inventory.save();
+    const itemId = changedInventory.toJSON<IInventoryClient>().Upgrades[itemIndex].ItemId.$oid;
+
+    if (!itemId) {
+        throw new Error("Item Id not found in upgradeMod");
+    }
+
+    res.send(itemId);
+    broadcastInventoryUpdate(req);
 };
 
-export { artifactsController };
+interface IArtifactsRequest {
+    Upgrade: IUpgradeClient;
+    LevelDiff: number;
+    Cost: number;
+    FusionPointCost: number;
+    LegendaryFusion?: boolean;
+}

src/controllers/api/cancelGuildAdvertisementController.ts

@@ -0,0 +1,20 @@
+import { GuildAd } from "../../models/guildModel.ts";
+import { getGuildForRequestEx, hasGuildPermission } from "../../services/guildService.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { GuildPermission } from "../../types/guildTypes.ts";
+import type { RequestHandler } from "express";
+
+export const cancelGuildAdvertisementController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "GuildId");
+    const guild = await getGuildForRequestEx(req, inventory);
+    if (!(await hasGuildPermission(guild, accountId, GuildPermission.Advertiser))) {
+        res.status(400).end();
+        return;
+    }
+
+    await GuildAd.deleteOne({ GuildId: guild._id });
+
+    res.end();
+};

src/controllers/api/changeDojoRootController.ts

@@ -0,0 +1,99 @@
+import type { RequestHandler } from "express";
+import {
+    getDojoClient,
+    getGuildForRequestEx,
+    hasAccessToDojo,
+    hasGuildPermission
+} from "../../services/guildService.ts";
+import { logger } from "../../utils/logger.ts";
+import type { IDojoComponentDatabase } from "../../types/guildTypes.ts";
+import { GuildPermission } from "../../types/guildTypes.ts";
+import { Types } from "mongoose";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+
+export const changeDojoRootController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "GuildId LevelKeys");
+    const guild = await getGuildForRequestEx(req, inventory);
+    if (!hasAccessToDojo(inventory) || !(await hasGuildPermission(guild, accountId, GuildPermission.Architect))) {
+        res.json({ DojoRequestStatus: -1 });
+        return;
+    }
+
+    // Example POST body: {"pivot":[0, 0, -64],"components":"{\"670429301ca0a63848ccc467\":{\"R\":[0,0,0],\"P\":[0,3,32]},\"6704254a1ca0a63848ccb33c\":{\"R\":[0,0,0],\"P\":[0,9.25,-32]},\"670429461ca0a63848ccc731\":{\"R\":[-90,0,0],\"P\":[-47.999992370605,3,16]}}"}
+    if (req.body) {
+        logger.debug(`data provided to ${req.path}: ${String(req.body)}`);
+        throw new Error("dojo reparent operation should not need deco repositioning"); // because we always provide SortId
+    }
+
+    const idToNode: Record<string, INode> = {};
+    guild.DojoComponents.forEach(x => {
+        idToNode[x._id.toString()] = {
+            component: x,
+            parent: undefined,
+            children: []
+        };
+    });
+
+    let oldRoot: INode | undefined;
+    guild.DojoComponents.forEach(x => {
+        const node = idToNode[x._id.toString()];
+        if (x.pi) {
+            idToNode[x.pi.toString()].children.push(node);
+            node.parent = idToNode[x.pi.toString()];
+        } else {
+            oldRoot = node;
+        }
+    });
+    logger.debug("Old tree:\n" + treeToString(oldRoot!));
+
+    const newRoot = idToNode[req.query.newRoot as string];
+    recursivelyTurnParentsIntoChildren(newRoot);
+    newRoot.component.pi = undefined;
+    newRoot.component.op = undefined;
+    newRoot.component.pp = undefined;
+    newRoot.parent = undefined;
+
+    // Set/update SortId in top-to-bottom order
+    const stack: INode[] = [newRoot];
+    while (stack.length != 0) {
+        const top = stack.shift()!;
+        top.component.SortId = new Types.ObjectId();
+        top.children.forEach(x => stack.push(x));
+    }
+
+    logger.debug("New tree:\n" + treeToString(newRoot));
+
+    await guild.save();
+
+    res.json(await getDojoClient(guild, 0));
+};
+
+interface INode {
+    component: IDojoComponentDatabase;
+    parent: INode | undefined;
+    children: INode[];
+}
+
+const treeToString = (root: INode, depth: number = 0): string => {
+    let str = " ".repeat(depth * 4) + root.component.pf + " (" + root.component._id.toString() + ")\n";
+    root.children.forEach(x => {
+        str += treeToString(x, depth + 1);
+    });
+    return str;
+};
+
+const recursivelyTurnParentsIntoChildren = (node: INode): void => {
+    if (node.parent!.parent) {
+        recursivelyTurnParentsIntoChildren(node.parent!);
+    }
+
+    node.parent!.component.pi = node.component._id;
+    node.parent!.component.op = node.component.pp;
+    node.parent!.component.pp = node.component.op;
+
+    node.parent!.parent = node;
+    node.parent!.children.splice(node.parent!.children.indexOf(node), 1);
+    node.children.push(node.parent!);
+};

src/controllers/api/changeGuildRankController.ts

@@ -0,0 +1,38 @@
+import { GuildMember } from "../../models/guildModel.ts";
+import { getGuildForRequest, hasGuildPermissionEx } from "../../services/guildService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { GuildPermission } from "../../types/guildTypes.ts";
+import type { RequestHandler } from "express";
+
+export const changeGuildRankController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const member = (await GuildMember.findOne({
+        accountId: accountId,
+        guildId: req.query.guildId as string
+    }))!;
+    const newRank: number = parseInt(req.query.rankChange as string);
+
+    const guild = await getGuildForRequest(req);
+    if (newRank < member.rank || !hasGuildPermissionEx(guild, member, GuildPermission.Promoter)) {
+        res.status(400).json("Invalid permission");
+        return;
+    }
+
+    const target = (await GuildMember.findOne({
+        guildId: req.query.guildId as string,
+        accountId: req.query.targetId as string
+    }))!;
+    target.rank = parseInt(req.query.rankChange as string);
+    await target.save();
+
+    if (newRank == 0) {
+        // If we just promoted someone else to Founding Warlord, we need to demote ourselves to Warlord.
+        member.rank = 1;
+        await member.save();
+    }
+
+    res.json({
+        _id: req.query.targetId as string,
+        Rank: newRank
+    });
+};

src/controllers/api/checkDailyMissionBonusController.ts

@@ -1,16 +1,12 @@
-import { RequestHandler } from "express";
+import { getAccountForRequest } from "../../services/loginService.ts";
+import type { RequestHandler } from "express";
 
-const checkDailyMissionBonusController: RequestHandler = (_req, res) => {
-    const data = Buffer.from([
-        0x44, 0x61, 0x69, 0x6c, 0x79, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x6f, 0x6e, 0x75, 0x73, 0x3a,
-        0x31, 0x2d, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x50, 0x56, 0x50, 0x57, 0x69, 0x6e, 0x42, 0x6f, 0x6e, 0x75, 0x73,
-        0x3a, 0x31, 0x0a
-    ]);
-    res.writeHead(200, {
-        "Content-Type": "text/html",
-        "Content-Length": data.length
-    });
-    res.end(data);
+export const checkDailyMissionBonusController: RequestHandler = async (req, res) => {
+    const account = await getAccountForRequest(req);
+    const today = Math.trunc(Date.now() / 86400000) * 86400;
+    if (account.DailyFirstWinDate != today) {
+        res.send("DailyMissionBonus:1-DailyPVPWinBonus:1\n");
+    } else {
+        res.send("DailyMissionBonus:0-DailyPVPWinBonus:1\n");
+    }
 };
-
-export { checkDailyMissionBonusController };

src/controllers/api/claimCompletedRecipeController.ts

@@ -1,88 +1,307 @@
 //this is a controller for the claimCompletedRecipe route
 //it will claim a recipe for the user
 
-import { RequestHandler } from "express";
-import { logger } from "@/src/utils/logger";
-import { getRecipe } from "@/src/services/itemDataService";
-import { IOid } from "@/src/types/commonTypes";
-import { getJSONfromString } from "@/src/helpers/stringHelpers";
-import { getAccountIdForRequest } from "@/src/services/loginService";
-import { getInventory, updateCurrency, addItem, addMiscItems, addRecipes } from "@/src/services/inventoryService";
+import type { RequestHandler } from "express";
+import { logger } from "../../utils/logger.ts";
+import { getRecipe } from "../../services/itemDataService.ts";
+import type { IOidWithLegacySupport } from "../../types/commonTypes.ts";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import type { TAccountDocument } from "../../services/loginService.ts";
+import { getAccountForRequest } from "../../services/loginService.ts";
+import {
+    getInventory,
+    updateCurrency,
+    addItem,
+    addRecipes,
+    occupySlot,
+    combineInventoryChanges,
+    addKubrowPetPrint,
+    addPowerSuit,
+    addEquipment
+} from "../../services/inventoryService.ts";
+import type { IInventoryChanges } from "../../types/purchaseTypes.ts";
+import type { IPendingRecipeDatabase } from "../../types/inventoryTypes/inventoryTypes.ts";
+import { InventorySlot } from "../../types/inventoryTypes/inventoryTypes.ts";
+import { fromOid, toOid2 } from "../../helpers/inventoryHelpers.ts";
+import type { TInventoryDatabaseDocument } from "../../models/inventoryModels/inventoryModel.ts";
+import type { IRecipe } from "warframe-public-export-plus";
+import type { IEquipmentClient } from "../../types/equipmentTypes.ts";
+import { EquipmentFeatures, Status } from "../../types/equipmentTypes.ts";
 
-export interface IClaimCompletedRecipeRequest {
-    RecipeIds: IOid[];
+interface IClaimCompletedRecipeRequest {
+    RecipeIds: IOidWithLegacySupport[];
+}
+
+interface IClaimCompletedRecipeResponse {
+    InventoryChanges: IInventoryChanges;
+    BrandedSuits?: IOidWithLegacySupport[];
 }
 
-// eslint-disable-next-line @typescript-eslint/no-misused-promises
 export const claimCompletedRecipeController: RequestHandler = async (req, res) => {
-    const claimCompletedRecipeRequest = getJSONfromString(String(req.body)) as IClaimCompletedRecipeRequest;
-    const accountId = await getAccountIdForRequest(req);
-    if (!accountId) throw new Error("no account id");
+    const claimCompletedRecipeRequest = getJSONfromString<IClaimCompletedRecipeRequest>(String(req.body));
+    const account = await getAccountForRequest(req);
+    const inventory = await getInventory(account._id.toString());
+    const resp: IClaimCompletedRecipeResponse = {
+        InventoryChanges: {}
+    };
+    for (const recipeId of claimCompletedRecipeRequest.RecipeIds) {
+        const pendingRecipe = inventory.PendingRecipes.id(fromOid(recipeId));
+        if (!pendingRecipe) {
+            throw new Error(`no pending recipe found with id ${fromOid(recipeId)}`);
+        }
 
-    const inventory = await getInventory(accountId);
-    const pendingRecipe = inventory.PendingRecipes.find(
-        recipe => recipe._id?.toString() === claimCompletedRecipeRequest.RecipeIds[0].$id
-    );
-    if (!pendingRecipe) {
-        logger.error(`no pending recipe found with id ${claimCompletedRecipeRequest.RecipeIds[0].$id}`);
-        throw new Error(`no pending recipe found with id ${claimCompletedRecipeRequest.RecipeIds[0].$id}`);
-    }
+        //check recipe is indeed ready to be completed
+        // if (pendingRecipe.CompletionDate > new Date()) {
+        //     throw new Error(`recipe ${pendingRecipe._id} is not ready to be completed`);
+        // }
 
-    //check recipe is indeed ready to be completed
-    // if (pendingRecipe.CompletionDate > new Date()) {
-    //     logger.error(`recipe ${pendingRecipe._id} is not ready to be completed`);
-    //     throw new Error(`recipe ${pendingRecipe._id} is not ready to be completed`);
-    // }
+        inventory.PendingRecipes.pull(pendingRecipe._id);
 
-    inventory.PendingRecipes.pull(pendingRecipe._id);
-    await inventory.save();
+        const recipe = getRecipe(pendingRecipe.ItemType);
+        if (!recipe) {
+            throw new Error(`no completed item found for recipe ${pendingRecipe._id.toString()}`);
+        }
 
-    const recipe = getRecipe(pendingRecipe.ItemType);
-    if (!recipe) {
-        logger.error(`no completed item found for recipe ${pendingRecipe._id}`);
-        throw new Error(`no completed item found for recipe ${pendingRecipe._id}`);
-    }
-
-    if (req.query.cancel) {
-        const currencyChanges = await updateCurrency(recipe.buildPrice * -1, false, accountId);
-
-        const inventory = await getInventory(accountId);
-        addMiscItems(inventory, recipe.ingredients);
-        await inventory.save();
-
-        // Not a bug: In the specific case of cancelling a recipe, InventoryChanges are expected to be the root.
-        res.json({
-            ...currencyChanges,
-            MiscItems: recipe.ingredients
-        });
-    } else {
-        logger.debug("Claiming Recipe", { recipe, pendingRecipe });
-        let InventoryChanges = {};
-        if (recipe.consumeOnUse) {
-            const recipeChanges = [
-                {
-                    ItemType: pendingRecipe.ItemType,
-                    ItemCount: -1
-                }
-            ];
-
-            InventoryChanges = { ...InventoryChanges, Recipes: recipeChanges };
-
-            const inventory = await getInventory(accountId);
-            addRecipes(inventory, recipeChanges);
+        if (req.query.cancel) {
+            const inventoryChanges: IInventoryChanges = {};
+            await refundRecipeIngredients(inventory, inventoryChanges, recipe, pendingRecipe);
             await inventory.save();
+            res.json(inventoryChanges); // Not a bug: In the specific case of cancelling a recipe, InventoryChanges are expected to be the root.
+            return;
         }
-        if (req.query.rush) {
-            InventoryChanges = {
-                ...InventoryChanges,
-                ...(await updateCurrency(recipe.skipBuildTimePrice, true, accountId))
-            };
-        }
-        res.json({
-            InventoryChanges: {
-                ...InventoryChanges,
-                ...(await addItem(accountId, recipe.resultType, recipe.num)).InventoryChanges
+
+        await claimCompletedRecipe(account, inventory, recipe, pendingRecipe, resp, req.query.rush);
+    }
+    await inventory.save();
+    res.json(resp);
+};
+
+const claimCompletedRecipe = async (
+    account: TAccountDocument,
+    inventory: TInventoryDatabaseDocument,
+    recipe: IRecipe,
+    pendingRecipe: IPendingRecipeDatabase,
+    resp: IClaimCompletedRecipeResponse,
+    rush: any
+): Promise<void> => {
+    logger.debug("Claiming Recipe", { recipe, pendingRecipe });
+
+    if (recipe.secretIngredientAction == "SIA_SPECTRE_LOADOUT_COPY") {
+        inventory.PendingSpectreLoadouts ??= [];
+        inventory.SpectreLoadouts ??= [];
+
+        const pendingLoadoutIndex = inventory.PendingSpectreLoadouts.findIndex(x => x.ItemType == recipe.resultType);
+        if (pendingLoadoutIndex != -1) {
+            const loadoutIndex = inventory.SpectreLoadouts.findIndex(x => x.ItemType == recipe.resultType);
+            if (loadoutIndex != -1) {
+                inventory.SpectreLoadouts.splice(loadoutIndex, 1);
             }
-        });
+            logger.debug(
+                "moving spectre loadout from pending to active",
+                inventory.toJSON().PendingSpectreLoadouts![pendingLoadoutIndex]
+            );
+            inventory.SpectreLoadouts.push(inventory.PendingSpectreLoadouts[pendingLoadoutIndex]);
+            inventory.PendingSpectreLoadouts.splice(pendingLoadoutIndex, 1);
+        }
+    } else if (recipe.secretIngredientAction == "SIA_UNBRAND") {
+        inventory.BrandedSuits!.splice(
+            inventory.BrandedSuits!.findIndex(x => x.equals(pendingRecipe.SuitToUnbrand)),
+            1
+        );
+        resp.BrandedSuits = [toOid2(pendingRecipe.SuitToUnbrand!, account.BuildLabel)];
+    }
+
+    if (recipe.consumeOnUse) {
+        addRecipes(inventory, [
+            {
+                ItemType: pendingRecipe.ItemType,
+                ItemCount: -1
+            }
+        ]);
+    }
+
+    if (rush) {
+        const end = Math.trunc(pendingRecipe.CompletionDate.getTime() / 1000);
+        const start = end - recipe.buildTime;
+        const secondsElapsed = Math.trunc(Date.now() / 1000) - start;
+        const progress = secondsElapsed / recipe.buildTime;
+        logger.debug(`rushing recipe at ${Math.trunc(progress * 100)}% completion`);
+        const cost =
+            progress > 0.5 ? Math.round(recipe.skipBuildTimePrice * (1 - (progress - 0.5))) : recipe.skipBuildTimePrice;
+        combineInventoryChanges(resp.InventoryChanges, updateCurrency(inventory, cost, true));
+    }
+
+    if (recipe.secretIngredientAction == "SIA_CREATE_KUBROW") {
+        const pet = inventory.KubrowPets.id(pendingRecipe.KubrowPet!)!;
+        if (pet.Details!.HatchDate!.getTime() > Date.now()) {
+            pet.Details!.HatchDate = new Date();
+        }
+        let canSetActive = true;
+        for (const pet of inventory.KubrowPets) {
+            if (pet.Details!.Status == Status.StatusAvailable) {
+                canSetActive = false;
+                break;
+            }
+        }
+        pet.Details!.Status = canSetActive ? Status.StatusAvailable : Status.StatusStasis;
+    } else if (recipe.secretIngredientAction == "SIA_DISTILL_PRINT") {
+        const pet = inventory.KubrowPets.id(pendingRecipe.KubrowPet!)!;
+        addKubrowPetPrint(inventory, pet, resp.InventoryChanges);
+    } else if (recipe.secretIngredientAction != "SIA_UNBRAND") {
+        if (recipe.resultType == "/Lotus/Powersuits/Excalibur/ExcaliburUmbra") {
+            // Quite the special case here...
+            // We don't just get Umbra, but also Skiajati and Umbra Mods. Both items are max rank, potatoed, and with the mods are pre-installed.
+            // Source: https://wiki.warframe.com/w/The_Sacrifice, https://wiki.warframe.com/w/Excalibur/Umbra, https://wiki.warframe.com/w/Skiajati
+
+            const umbraModA = (
+                await addItem(
+                    inventory,
+                    "/Lotus/Upgrades/Mods/Sets/Umbra/WarframeUmbraModA",
+                    1,
+                    false,
+                    undefined,
+                    `{"lvl":5}`
+                )
+            ).Upgrades![0];
+            const umbraModB = (
+                await addItem(
+                    inventory,
+                    "/Lotus/Upgrades/Mods/Sets/Umbra/WarframeUmbraModB",
+                    1,
+                    false,
+                    undefined,
+                    `{"lvl":5}`
+                )
+            ).Upgrades![0];
+            const umbraModC = (
+                await addItem(
+                    inventory,
+                    "/Lotus/Upgrades/Mods/Sets/Umbra/WarframeUmbraModC",
+                    1,
+                    false,
+                    undefined,
+                    `{"lvl":5}`
+                )
+            ).Upgrades![0];
+            const sacrificeModA = (
+                await addItem(
+                    inventory,
+                    "/Lotus/Upgrades/Mods/Sets/Sacrifice/MeleeSacrificeModA",
+                    1,
+                    false,
+                    undefined,
+                    `{"lvl":5}`
+                )
+            ).Upgrades![0];
+            const sacrificeModB = (
+                await addItem(
+                    inventory,
+                    "/Lotus/Upgrades/Mods/Sets/Sacrifice/MeleeSacrificeModB",
+                    1,
+                    false,
+                    undefined,
+                    `{"lvl":5}`
+                )
+            ).Upgrades![0];
+            resp.InventoryChanges.Upgrades ??= [];
+            resp.InventoryChanges.Upgrades.push(umbraModA, umbraModB, umbraModC, sacrificeModA, sacrificeModB);
+
+            await addPowerSuit(
+                inventory,
+                "/Lotus/Powersuits/Excalibur/ExcaliburUmbra",
+                {
+                    Configs: [
+                        {
+                            Upgrades: [
+                                "",
+                                "",
+                                "",
+                                "",
+                                "",
+                                umbraModA.ItemId.$oid,
+                                umbraModB.ItemId.$oid,
+                                umbraModC.ItemId.$oid
+                            ]
+                        }
+                    ],
+                    XP: 900_000,
+                    Features: EquipmentFeatures.DOUBLE_CAPACITY
+                },
+                resp.InventoryChanges
+            );
+            inventory.XPInfo.push({
+                ItemType: "/Lotus/Powersuits/Excalibur/ExcaliburUmbra",
+                XP: 900_000
+            });
+
+            addEquipment(
+                inventory,
+                "Melee",
+                "/Lotus/Weapons/Tenno/Melee/Swords/UmbraKatana/UmbraKatana",
+                {
+                    Configs: [
+                        { Upgrades: ["", "", "", "", "", "", sacrificeModA.ItemId.$oid, sacrificeModB.ItemId.$oid] }
+                    ],
+                    XP: 450_000,
+                    Features: EquipmentFeatures.DOUBLE_CAPACITY
+                },
+                resp.InventoryChanges
+            );
+            inventory.XPInfo.push({
+                ItemType: "/Lotus/Weapons/Tenno/Melee/Swords/UmbraKatana/UmbraKatana",
+                XP: 450_000
+            });
+        } else {
+            combineInventoryChanges(
+                resp.InventoryChanges,
+                await addItem(
+                    inventory,
+                    recipe.resultType,
+                    recipe.num,
+                    false,
+                    undefined,
+                    pendingRecipe.TargetFingerprint
+                )
+            );
+        }
+    }
+    if (
+        inventory.claimingBlueprintRefundsIngredients &&
+        recipe.secretIngredientAction != "SIA_CREATE_KUBROW" // Can't refund the egg
+    ) {
+        await refundRecipeIngredients(inventory, resp.InventoryChanges, recipe, pendingRecipe);
+    }
+};
+
+const refundRecipeIngredients = async (
+    inventory: TInventoryDatabaseDocument,
+    inventoryChanges: IInventoryChanges,
+    recipe: IRecipe,
+    pendingRecipe: IPendingRecipeDatabase
+): Promise<void> => {
+    updateCurrency(inventory, recipe.buildPrice * -1, false, inventoryChanges);
+
+    const equipmentIngredients = new Set();
+    for (const category of ["LongGuns", "Pistols", "Melee"] as const) {
+        if (pendingRecipe[category]) {
+            pendingRecipe[category].forEach(item => {
+                const index = inventory[category].push(item) - 1;
+                inventoryChanges[category] ??= [];
+                inventoryChanges[category].push(inventory[category][index].toJSON<IEquipmentClient>());
+                equipmentIngredients.add(item.ItemType);
+
+                occupySlot(inventory, InventorySlot.WEAPONS, false);
+                inventoryChanges.WeaponBin ??= { Slots: 0 };
+                inventoryChanges.WeaponBin.Slots -= 1;
+            });
+        }
+    }
+    for (const ingredient of recipe.ingredients) {
+        if (!equipmentIngredients.has(ingredient.ItemType)) {
+            combineInventoryChanges(
+                inventoryChanges,
+                await addItem(inventory, ingredient.ItemType, ingredient.ItemCount)
+            );
+        }
     }
 };

src/controllers/api/claimJunctionChallengeRewardController.ts

@@ -0,0 +1,35 @@
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { combineInventoryChanges, getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { handleStoreItemAcquisition } from "../../services/purchaseService.ts";
+import type { RequestHandler } from "express";
+import { ExportChallenges } from "warframe-public-export-plus";
+
+export const claimJunctionChallengeRewardController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId);
+    const data = getJSONfromString<IClaimJunctionChallengeRewardRequest>(String(req.body));
+    const challengeProgress = inventory.ChallengeProgress.find(x => x.Name == data.Challenge)!;
+    if (challengeProgress.ReceivedJunctionReward) {
+        throw new Error(`attempt to double-claim junction reward`);
+    }
+    challengeProgress.ReceivedJunctionReward = true;
+    inventory.ClaimedJunctionChallengeRewards ??= [];
+    inventory.ClaimedJunctionChallengeRewards.push(data.Challenge);
+    const challengeMeta = Object.entries(ExportChallenges).find(arr => arr[0].endsWith("/" + data.Challenge))![1];
+    const inventoryChanges = {};
+    for (const reward of challengeMeta.countedRewards!) {
+        combineInventoryChanges(
+            inventoryChanges,
+            (await handleStoreItemAcquisition(reward.StoreItem, inventory, reward.ItemCount)).InventoryChanges
+        );
+    }
+    await inventory.save();
+    res.json({
+        inventoryChanges: inventoryChanges // Yeah, it's "inventoryChanges" in the response here.
+    });
+};
+
+interface IClaimJunctionChallengeRewardRequest {
+    Challenge: string;
+}

src/controllers/api/claimLibraryDailyTaskRewardController.ts

@@ -0,0 +1,31 @@
+import { addFusionPoints, getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { RequestHandler } from "express";
+
+export const claimLibraryDailyTaskRewardController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId);
+
+    const rewardQuantity = inventory.LibraryActiveDailyTaskInfo!.RewardQuantity;
+    const rewardStanding = inventory.LibraryActiveDailyTaskInfo!.RewardStanding;
+    inventory.LibraryActiveDailyTaskInfo = undefined;
+    inventory.LibraryAvailableDailyTaskInfo = undefined;
+
+    let syndicate = inventory.Affiliations.find(x => x.Tag == "LibrarySyndicate");
+    if (!syndicate) {
+        syndicate = inventory.Affiliations[inventory.Affiliations.push({ Tag: "LibrarySyndicate", Standing: 0 }) - 1];
+    }
+    syndicate.Standing += rewardStanding;
+
+    addFusionPoints(inventory, 80 * rewardQuantity);
+    await inventory.save();
+
+    res.json({
+        RewardItem: "/Lotus/StoreItems/Upgrades/Mods/FusionBundles/RareFusionBundle",
+        RewardQuantity: rewardQuantity,
+        StandingAwarded: rewardStanding,
+        InventoryChanges: {
+            FusionPoints: 80 * rewardQuantity
+        }
+    });
+};

src/controllers/api/clearDialogueHistoryController.ts

@@ -0,0 +1,25 @@
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { RequestHandler } from "express";
+
+export const clearDialogueHistoryController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId);
+    const request = JSON.parse(String(req.body)) as IClearDialogueRequest;
+    if (inventory.DialogueHistory && inventory.DialogueHistory.Dialogues) {
+        inventory.DialogueHistory.Resets ??= 0;
+        inventory.DialogueHistory.Resets += 1;
+        for (const dialogueName of request.Dialogues) {
+            const index = inventory.DialogueHistory.Dialogues.findIndex(x => x.DialogueName == dialogueName);
+            if (index != -1) {
+                inventory.DialogueHistory.Dialogues.splice(index, 1);
+            }
+        }
+    }
+    await inventory.save();
+    res.end();
+};
+
+interface IClearDialogueRequest {
+    Dialogues: string[];
+}

src/controllers/api/clearNewEpisodeRewardController.ts

@@ -0,0 +1,6 @@
+import type { RequestHandler } from "express";
+
+// example req.body: {"NewEpisodeReward":true,"crossPlaySetting":"ENABLED"}
+export const clearNewEpisodeRewardController: RequestHandler = (_req, res) => {
+    res.status(200).end();
+};

src/controllers/api/completeCalendarEventController.ts

@@ -0,0 +1,37 @@
+import { checkCalendarAutoAdvance, getCalendarProgress, getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { handleStoreItemAcquisition } from "../../services/purchaseService.ts";
+import { getWorldState } from "../../services/worldStateService.ts";
+import type { IInventoryChanges } from "../../types/purchaseTypes.ts";
+import type { RequestHandler } from "express";
+
+// GET request; query parameters: CompletedEventIdx=0&Iteration=4&Version=19&Season=CST_SUMMER
+export const completeCalendarEventController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId);
+    const calendarProgress = getCalendarProgress(inventory);
+    const currentSeason = getWorldState().KnownCalendarSeasons[0];
+    let inventoryChanges: IInventoryChanges = {};
+    const dayIndex = calendarProgress.SeasonProgress.LastCompletedDayIdx + 1;
+    const day = currentSeason.Days[dayIndex];
+    if (day.events.length != 0) {
+        if (day.events[0].type == "CET_CHALLENGE") {
+            throw new Error(`completeCalendarEvent should not be used for challenges`);
+        }
+        const selection = day.events[parseInt(req.query.CompletedEventIdx as string)];
+        if (selection.type == "CET_REWARD") {
+            inventoryChanges = (await handleStoreItemAcquisition(selection.reward!, inventory)).InventoryChanges;
+        } else if (selection.type == "CET_UPGRADE") {
+            calendarProgress.YearProgress.Upgrades.push(selection.upgrade!);
+        } else if (selection.type != "CET_PLOT") {
+            throw new Error(`unexpected selection type: ${selection.type}`);
+        }
+    }
+    calendarProgress.SeasonProgress.LastCompletedDayIdx = dayIndex;
+    checkCalendarAutoAdvance(inventory, currentSeason);
+    await inventory.save();
+    res.json({
+        InventoryChanges: inventoryChanges,
+        CalendarProgress: inventory.CalendarProgress
+    });
+};

src/controllers/api/completeRandomModChallengeController.ts

@@ -0,0 +1,45 @@
+import type { RequestHandler } from "express";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { addMiscItems, getInventory, updateCurrency } from "../../services/inventoryService.ts";
+import type { IInventoryChanges } from "../../types/purchaseTypes.ts";
+import type { IMiscItem } from "../../types/inventoryTypes/inventoryTypes.ts";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import type { IVeiledRivenFingerprint } from "../../helpers/rivenHelper.ts";
+
+export const completeRandomModChallengeController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId);
+    const request = getJSONfromString<ICompleteRandomModChallengeRequest>(String(req.body));
+    let inventoryChanges: IInventoryChanges = {};
+
+    // Remove 20 plat or riven cipher
+    if ((req.query.p as string) == "1") {
+        inventoryChanges = { ...updateCurrency(inventory, 20, true) };
+    } else {
+        const miscItemChanges: IMiscItem[] = [
+            {
+                ItemType: "/Lotus/Types/Items/MiscItems/RivenIdentifier",
+                ItemCount: -1
+            }
+        ];
+        addMiscItems(inventory, miscItemChanges);
+        inventoryChanges.MiscItems = miscItemChanges;
+    }
+
+    // Complete the riven challenge
+    const upgrade = inventory.Upgrades.id(request.ItemId)!;
+    const fp = JSON.parse(upgrade.UpgradeFingerprint!) as IVeiledRivenFingerprint;
+    fp.challenge.Progress = fp.challenge.Required;
+    upgrade.UpgradeFingerprint = JSON.stringify(fp);
+
+    await inventory.save();
+
+    res.json({
+        InventoryChanges: inventoryChanges,
+        Fingerprint: upgrade.UpgradeFingerprint
+    });
+};
+
+interface ICompleteRandomModChallengeRequest {
+    ItemId: string;
+}

src/controllers/api/confirmAllianceInvitationController.ts

@@ -0,0 +1,37 @@
+import { Alliance, AllianceMember, Guild, GuildMember } from "../../models/guildModel.ts";
+import { getAllianceClient } from "../../services/guildService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { RequestHandler } from "express";
+
+export const confirmAllianceInvitationController: RequestHandler = async (req, res) => {
+    // Check requester is a warlord in their guild
+    const accountId = await getAccountIdForRequest(req);
+    const guildMember = (await GuildMember.findOne({ accountId, status: 0 }))!;
+    if (guildMember.rank > 1) {
+        res.status(400).json({ Error: 104 });
+        return;
+    }
+
+    const allianceMember = await AllianceMember.findOne({
+        allianceId: req.query.allianceId,
+        guildId: guildMember.guildId
+    });
+    if (!allianceMember || !allianceMember.Pending) {
+        res.status(400);
+        return;
+    }
+    allianceMember.Pending = false;
+
+    const guild = (await Guild.findById(guildMember.guildId))!;
+    guild.AllianceId = allianceMember.allianceId;
+
+    await Promise.all([allianceMember.save(), guild.save()]);
+
+    // Give client the new alliance data which uses "AllianceId" instead of "_id" in this response
+    const alliance = (await Alliance.findById(allianceMember.allianceId))!;
+    const { _id, ...rest } = await getAllianceClient(alliance, guild);
+    res.json({
+        AllianceId: _id,
+        ...rest
+    });
+};

src/controllers/api/confirmGuildInvitationController.ts

@@ -0,0 +1,118 @@
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { Guild, GuildMember } from "../../models/guildModel.ts";
+import { Account } from "../../models/loginModel.ts";
+import {
+    deleteGuild,
+    getGuildClient,
+    giveClanKey,
+    hasGuildPermission,
+    removeDojoKeyItems
+} from "../../services/guildService.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountForRequest, getAccountIdForRequest, getSuffixedName } from "../../services/loginService.ts";
+import { GuildPermission } from "../../types/guildTypes.ts";
+import type { IInventoryChanges } from "../../types/purchaseTypes.ts";
+import type { RequestHandler } from "express";
+import { Types } from "mongoose";
+
+// GET request: A player accepting an invite they got in their inbox.
+export const confirmGuildInvitationGetController: RequestHandler = async (req, res) => {
+    const account = await getAccountForRequest(req);
+    const invitedGuildMember = await GuildMember.findOne({
+        accountId: account._id,
+        guildId: req.query.clanId as string
+    });
+    if (invitedGuildMember && invitedGuildMember.status == 2) {
+        let inventoryChanges: IInventoryChanges = {};
+
+        // If this account is already in a guild, we need to do cleanup first.
+        const guildMember = await GuildMember.findOneAndDelete({ accountId: account._id, status: 0 });
+        if (guildMember) {
+            const inventory = await getInventory(account._id.toString(), "LevelKeys Recipes");
+            inventoryChanges = removeDojoKeyItems(inventory);
+            await inventory.save();
+
+            if (guildMember.rank == 0) {
+                await deleteGuild(guildMember.guildId);
+            }
+        }
+
+        // Now that we're sure this account is not in a guild right now, we can just proceed with the normal updates.
+        invitedGuildMember.status = 0;
+        await invitedGuildMember.save();
+
+        // Remove pending applications for this account
+        await GuildMember.deleteMany({ accountId: account._id, status: 1 });
+
+        // Update inventory of new member
+        const inventory = await getInventory(account._id.toString(), "GuildId LevelKeys Recipes");
+        inventory.GuildId = new Types.ObjectId(req.query.clanId as string);
+        giveClanKey(inventory, inventoryChanges);
+        await inventory.save();
+
+        const guild = (await Guild.findById(req.query.clanId as string))!;
+
+        // Add join to clan log
+        guild.RosterActivity ??= [];
+        guild.RosterActivity.push({
+            dateTime: new Date(),
+            entryType: 6,
+            details: getSuffixedName(account)
+        });
+        await guild.save();
+
+        res.json({
+            ...(await getGuildClient(guild, account)),
+            InventoryChanges: inventoryChanges
+        });
+    } else {
+        res.end();
+    }
+};
+
+// POST request: Clan representative accepting invite(s).
+export const confirmGuildInvitationPostController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const guild = (await Guild.findById(req.query.clanId as string, "Ranks RosterActivity"))!;
+    if (!(await hasGuildPermission(guild, accountId, GuildPermission.Recruiter))) {
+        res.status(400).json("Invalid permission");
+        return;
+    }
+    const payload = getJSONfromString<{ userId: string }>(String(req.body));
+    const filter: { accountId?: string; status: number } = { status: 1 };
+    if (payload.userId != "all") {
+        filter.accountId = payload.userId;
+    }
+    const guildMembers = await GuildMember.find(filter);
+    const newMembers: string[] = [];
+    for (const guildMember of guildMembers) {
+        guildMember.status = 0;
+        guildMember.RequestMsg = undefined;
+        guildMember.RequestExpiry = undefined;
+        await guildMember.save();
+
+        // Remove other pending applications for this account
+        await GuildMember.deleteMany({ accountId: guildMember.accountId, status: 1 });
+
+        // Update inventory of new member
+        const inventory = await getInventory(guildMember.accountId.toString(), "GuildId LevelKeys Recipes");
+        inventory.GuildId = new Types.ObjectId(req.query.clanId as string);
+        giveClanKey(inventory);
+        await inventory.save();
+
+        // Add join to clan log
+        const account = (await Account.findOne({ _id: guildMember.accountId }))!;
+        guild.RosterActivity ??= [];
+        guild.RosterActivity.push({
+            dateTime: new Date(),
+            entryType: 6,
+            details: getSuffixedName(account)
+        });
+
+        newMembers.push(account._id.toString());
+    }
+    await guild.save();
+    res.json({
+        NewMembers: newMembers
+    });
+};

src/controllers/api/contributeGuildClassController.ts

@@ -0,0 +1,67 @@
+import { toMongoDate } from "../../helpers/inventoryHelpers.ts";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { Guild } from "../../models/guildModel.ts";
+import { checkClanAscensionHasRequiredContributors } from "../../services/guildService.ts";
+import { addFusionPoints, getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { RequestHandler } from "express";
+import { Types } from "mongoose";
+
+export const contributeGuildClassController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const payload = getJSONfromString<IContributeGuildClassRequest>(String(req.body));
+    const guild = (await Guild.findById(payload.GuildId))!;
+
+    // First contributor initiates ceremony and locks the pending class.
+    if (!guild.CeremonyContributors) {
+        guild.CeremonyContributors = [];
+        guild.CeremonyClass = guildXpToClass(guild.XP);
+        guild.CeremonyEndo = 0;
+        for (let i = guild.Class; i != guild.CeremonyClass; ++i) {
+            guild.CeremonyEndo += (i + 1) * 1000;
+        }
+        guild.ClassChanges ??= [];
+        guild.ClassChanges.push({
+            dateTime: new Date(),
+            entryType: 13,
+            details: guild.CeremonyClass
+        });
+    }
+
+    guild.CeremonyContributors.push(new Types.ObjectId(accountId));
+
+    await checkClanAscensionHasRequiredContributors(guild);
+
+    await guild.save();
+
+    // Either way, endo is given to the contributor.
+    const inventory = await getInventory(accountId, "FusionPoints");
+    addFusionPoints(inventory, guild.CeremonyEndo!);
+    await inventory.save();
+
+    res.json({
+        NumContributors: guild.CeremonyContributors.length,
+        FusionPointReward: guild.CeremonyEndo,
+        Class: guild.Class,
+        CeremonyResetDate: guild.CeremonyResetDate ? toMongoDate(guild.CeremonyResetDate) : undefined
+    });
+};
+
+interface IContributeGuildClassRequest {
+    GuildId: string;
+    RequiredContributors: number;
+}
+
+const guildXpToClass = (xp: number): number => {
+    const cummXp = [
+        0, 11000, 34000, 69000, 114000, 168000, 231000, 302000, 381000, 68000, 563000, 665000, 774000, 891000
+    ];
+    let highest = 0;
+    for (let i = 0; i != cummXp.length; ++i) {
+        if (xp < cummXp[i]) {
+            break;
+        }
+        highest = i;
+    }
+    return highest;
+};

src/controllers/api/contributeToDojoComponentController.ts

@@ -0,0 +1,170 @@
+import type { TGuildDatabaseDocument } from "../../models/guildModel.ts";
+import { GuildMember } from "../../models/guildModel.ts";
+import type { TInventoryDatabaseDocument } from "../../models/inventoryModels/inventoryModel.ts";
+import {
+    addGuildMemberMiscItemContribution,
+    getDojoClient,
+    getGuildForRequestEx,
+    hasAccessToDojo,
+    processDojoBuildMaterialsGathered,
+    scaleRequiredCount,
+    setDojoRoomLogFunded
+} from "../../services/guildService.ts";
+import { addMiscItems, getInventory, updateCurrency } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { IDojoContributable, IGuildMemberDatabase } from "../../types/guildTypes.ts";
+import type { IMiscItem } from "../../types/inventoryTypes/inventoryTypes.ts";
+import type { IInventoryChanges } from "../../types/purchaseTypes.ts";
+import type { RequestHandler } from "express";
+import type { IDojoBuild } from "warframe-public-export-plus";
+import { ExportDojoRecipes } from "warframe-public-export-plus";
+
+interface IContributeToDojoComponentRequest {
+    ComponentId: string;
+    DecoId?: string;
+    DecoType?: string;
+    IngredientContributions: IMiscItem[];
+    RegularCredits: number;
+    VaultIngredientContributions: IMiscItem[];
+    VaultCredits: number;
+}
+
+export const contributeToDojoComponentController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId);
+    // Any clan member should have permission to contribute although notably permission is denied if they have not crafted the dojo key and were simply invited in.
+    if (!hasAccessToDojo(inventory)) {
+        res.json({ DojoRequestStatus: -1 });
+        return;
+    }
+    const guild = await getGuildForRequestEx(req, inventory);
+    const guildMember = (await GuildMember.findOne(
+        { accountId, guildId: guild._id },
+        "RegularCreditsContributed MiscItemsContributed"
+    ))!;
+    const request = JSON.parse(String(req.body)) as IContributeToDojoComponentRequest;
+    const component = guild.DojoComponents.id(request.ComponentId)!;
+
+    const inventoryChanges: IInventoryChanges = {};
+    if (!component.CompletionTime) {
+        // Room is in "Collecting Materials" state
+        if (request.DecoId) {
+            throw new Error("attempt to contribute to a deco in an unfinished room?!");
+        }
+        const meta = Object.values(ExportDojoRecipes.rooms).find(x => x.resultType == component.pf)!;
+        processContribution(guild, guildMember, request, inventory, inventoryChanges, meta, component);
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (component.CompletionTime) {
+            setDojoRoomLogFunded(guild, component);
+        }
+    } else {
+        // Room is past "Collecting Materials"
+        if (request.DecoId) {
+            const deco = component.Decos!.find(x => x._id.equals(request.DecoId))!;
+            const meta = Object.values(ExportDojoRecipes.decos).find(x => x.resultType == deco.Type)!;
+            processContribution(guild, guildMember, request, inventory, inventoryChanges, meta, deco);
+        }
+    }
+
+    await Promise.all([guild.save(), inventory.save(), guildMember.save()]);
+    res.json({
+        ...(await getDojoClient(guild, 0, component._id)),
+        InventoryChanges: inventoryChanges
+    });
+};
+
+const processContribution = (
+    guild: TGuildDatabaseDocument,
+    guildMember: IGuildMemberDatabase,
+    request: IContributeToDojoComponentRequest,
+    inventory: TInventoryDatabaseDocument,
+    inventoryChanges: IInventoryChanges,
+    meta: IDojoBuild,
+    component: IDojoContributable
+): void => {
+    component.RegularCredits ??= 0;
+    if (request.RegularCredits) {
+        component.RegularCredits += request.RegularCredits;
+        inventoryChanges.RegularCredits = -request.RegularCredits;
+        updateCurrency(inventory, request.RegularCredits, false);
+
+        guildMember.RegularCreditsContributed ??= 0;
+        guildMember.RegularCreditsContributed += request.RegularCredits;
+    }
+    if (request.VaultCredits) {
+        component.RegularCredits += request.VaultCredits;
+        guild.VaultRegularCredits! -= request.VaultCredits;
+    }
+    if (component.RegularCredits > scaleRequiredCount(guild.Tier, meta.price)) {
+        guild.VaultRegularCredits ??= 0;
+        guild.VaultRegularCredits += component.RegularCredits - scaleRequiredCount(guild.Tier, meta.price);
+        component.RegularCredits = scaleRequiredCount(guild.Tier, meta.price);
+    }
+
+    component.MiscItems ??= [];
+    if (request.VaultIngredientContributions.length) {
+        for (const ingredientContribution of request.VaultIngredientContributions) {
+            const componentMiscItem = component.MiscItems.find(x => x.ItemType == ingredientContribution.ItemType);
+            if (componentMiscItem) {
+                const ingredientMeta = meta.ingredients.find(x => x.ItemType == ingredientContribution.ItemType)!;
+                if (
+                    componentMiscItem.ItemCount + ingredientContribution.ItemCount >
+                    scaleRequiredCount(guild.Tier, ingredientMeta.ItemCount)
+                ) {
+                    ingredientContribution.ItemCount =
+                        scaleRequiredCount(guild.Tier, ingredientMeta.ItemCount) - componentMiscItem.ItemCount;
+                }
+                componentMiscItem.ItemCount += ingredientContribution.ItemCount;
+            } else {
+                component.MiscItems.push(ingredientContribution);
+            }
+            const vaultMiscItem = guild.VaultMiscItems!.find(x => x.ItemType == ingredientContribution.ItemType)!;
+            vaultMiscItem.ItemCount -= ingredientContribution.ItemCount;
+        }
+    }
+    if (request.IngredientContributions.length) {
+        const miscItemChanges: IMiscItem[] = [];
+        for (const ingredientContribution of request.IngredientContributions) {
+            const componentMiscItem = component.MiscItems.find(x => x.ItemType == ingredientContribution.ItemType);
+            if (componentMiscItem) {
+                const ingredientMeta = meta.ingredients.find(x => x.ItemType == ingredientContribution.ItemType)!;
+                if (
+                    componentMiscItem.ItemCount + ingredientContribution.ItemCount >
+                    scaleRequiredCount(guild.Tier, ingredientMeta.ItemCount)
+                ) {
+                    ingredientContribution.ItemCount =
+                        scaleRequiredCount(guild.Tier, ingredientMeta.ItemCount) - componentMiscItem.ItemCount;
+                }
+                componentMiscItem.ItemCount += ingredientContribution.ItemCount;
+            } else {
+                component.MiscItems.push(ingredientContribution);
+            }
+            miscItemChanges.push({
+                ItemType: ingredientContribution.ItemType,
+                ItemCount: ingredientContribution.ItemCount * -1
+            });
+
+            addGuildMemberMiscItemContribution(guildMember, ingredientContribution);
+        }
+        addMiscItems(inventory, miscItemChanges);
+        inventoryChanges.MiscItems = miscItemChanges;
+    }
+
+    if (component.RegularCredits >= scaleRequiredCount(guild.Tier, meta.price)) {
+        let fullyFunded = true;
+        for (const ingredient of meta.ingredients) {
+            const componentMiscItem = component.MiscItems.find(x => x.ItemType == ingredient.ItemType);
+            if (
+                !componentMiscItem ||
+                componentMiscItem.ItemCount < scaleRequiredCount(guild.Tier, ingredient.ItemCount)
+            ) {
+                fullyFunded = false;
+                break;
+            }
+        }
+        if (fullyFunded) {
+            component.CompletionTime = new Date(Date.now() + meta.time * 1000);
+            processDojoBuildMaterialsGathered(guild, meta);
+        }
+    }
+};

src/controllers/api/contributeToVaultController.ts

@@ -0,0 +1,109 @@
+import type { TGuildDatabaseDocument, TGuildMemberDatabaseDocument } from "../../models/guildModel.ts";
+import { Alliance, Guild, GuildMember } from "../../models/guildModel.ts";
+import {
+    addGuildMemberMiscItemContribution,
+    addGuildMemberShipDecoContribution,
+    addVaultFusionTreasures,
+    addVaultMiscItems,
+    addVaultShipDecos,
+    getGuildForRequestEx
+} from "../../services/guildService.ts";
+import {
+    addFusionTreasures,
+    addMiscItems,
+    addShipDecorations,
+    getInventory,
+    updateCurrency
+} from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { ITypeCount } from "../../types/commonTypes.ts";
+import type { IFusionTreasure, IMiscItem } from "../../types/inventoryTypes/inventoryTypes.ts";
+import type { RequestHandler } from "express";
+
+export const contributeToVaultController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "GuildId RegularCredits MiscItems ShipDecorations FusionTreasures");
+    const request = JSON.parse(String(req.body)) as IContributeToVaultRequest;
+
+    if (request.Alliance) {
+        const guild = await getGuildForRequestEx(req, inventory);
+        const alliance = (await Alliance.findById(guild.AllianceId!))!;
+        alliance.VaultRegularCredits ??= 0;
+        alliance.VaultRegularCredits += request.RegularCredits;
+        if (request.FromVault) {
+            guild.VaultRegularCredits! -= request.RegularCredits;
+            await Promise.all([guild.save(), alliance.save()]);
+        } else {
+            updateCurrency(inventory, request.RegularCredits, false);
+            await Promise.all([inventory.save(), alliance.save()]);
+        }
+        res.end();
+        return;
+    }
+
+    let guild: TGuildDatabaseDocument;
+    let guildMember: TGuildMemberDatabaseDocument | undefined;
+    if (request.GuildVault) {
+        guild = (await Guild.findById(request.GuildVault))!;
+    } else {
+        guild = await getGuildForRequestEx(req, inventory);
+        guildMember = (await GuildMember.findOne(
+            { accountId, guildId: guild._id },
+            "RegularCreditsContributed MiscItemsContributed ShipDecorationsContributed"
+        ))!;
+    }
+
+    if (request.RegularCredits) {
+        updateCurrency(inventory, request.RegularCredits, false);
+
+        guild.VaultRegularCredits ??= 0;
+        guild.VaultRegularCredits += request.RegularCredits;
+
+        if (guildMember) {
+            guildMember.RegularCreditsContributed ??= 0;
+            guildMember.RegularCreditsContributed += request.RegularCredits;
+        }
+    }
+    if (request.MiscItems.length) {
+        addVaultMiscItems(guild, request.MiscItems);
+        for (const item of request.MiscItems) {
+            if (guildMember) {
+                addGuildMemberMiscItemContribution(guildMember, item);
+            }
+            addMiscItems(inventory, [{ ...item, ItemCount: item.ItemCount * -1 }]);
+        }
+    }
+    if (request.ShipDecorations.length) {
+        addVaultShipDecos(guild, request.ShipDecorations);
+        for (const item of request.ShipDecorations) {
+            if (guildMember) {
+                addGuildMemberShipDecoContribution(guildMember, item);
+            }
+            addShipDecorations(inventory, [{ ...item, ItemCount: item.ItemCount * -1 }]);
+        }
+    }
+    if (request.FusionTreasures.length) {
+        addVaultFusionTreasures(guild, request.FusionTreasures);
+        for (const item of request.FusionTreasures) {
+            addFusionTreasures(inventory, [{ ...item, ItemCount: item.ItemCount * -1 }]);
+        }
+    }
+
+    const promises: Promise<unknown>[] = [guild.save(), inventory.save()];
+    if (guildMember) {
+        promises.push(guildMember.save());
+    }
+    await Promise.all(promises);
+
+    res.end();
+};
+
+interface IContributeToVaultRequest {
+    RegularCredits: number;
+    MiscItems: IMiscItem[];
+    ShipDecorations: ITypeCount[];
+    FusionTreasures: IFusionTreasure[];
+    Alliance?: boolean;
+    FromVault?: boolean;
+    GuildVault?: string;
+}

src/controllers/api/createAllianceController.ts

@@ -0,0 +1,50 @@
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { Alliance, AllianceMember, Guild, GuildMember } from "../../models/guildModel.ts";
+import { getAllianceClient } from "../../services/guildService.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { GuildPermission } from "../../types/guildTypes.ts";
+import type { RequestHandler } from "express";
+
+export const createAllianceController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "GuildId");
+    const guild = (await Guild.findById(inventory.GuildId!, "Name Tier AllianceId"))!;
+    if (guild.AllianceId) {
+        res.status(400).send("Guild is already in an alliance").end();
+        return;
+    }
+    const guildMember = (await GuildMember.findOne({ guildId: guild._id, accountId }, "rank"))!;
+    if (guildMember.rank > 1) {
+        res.status(400).send("Invalid permission").end();
+        return;
+    }
+    const data = getJSONfromString<ICreateAllianceRequest>(String(req.body));
+    const alliance = new Alliance({ Name: data.allianceName });
+    try {
+        await alliance.save();
+    } catch (e) {
+        res.status(400).send("Alliance name already in use").end();
+        return;
+    }
+    guild.AllianceId = alliance._id;
+    await Promise.all([
+        guild.save(),
+        AllianceMember.insertOne({
+            allianceId: alliance._id,
+            guildId: guild._id,
+            Pending: false,
+            Permissions:
+                GuildPermission.Ruler |
+                GuildPermission.Promoter |
+                GuildPermission.Recruiter |
+                GuildPermission.Treasurer |
+                GuildPermission.ChatModerator
+        })
+    ]);
+    res.json(await getAllianceClient(alliance, guild));
+};
+
+interface ICreateAllianceRequest {
+    allianceName: string;
+}

src/controllers/api/createGuildController.ts

@@ -1,38 +1,56 @@
-import { RequestHandler } from "express";
-import { getAccountIdForRequest } from "@/src/services/loginService";
-import { getJSONfromString } from "@/src/helpers/stringHelpers";
-import { Inventory } from "@/src/models/inventoryModels/inventoryModel";
-import { Guild } from "@/src/models/guildModel";
-import { ICreateGuildRequest } from "@/src/types/guildTypes";
+import type { RequestHandler } from "express";
+import { getAccountForRequest } from "../../services/loginService.ts";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { Guild, GuildMember } from "../../models/guildModel.ts";
+import { createUniqueClanName, getGuildClient, giveClanKey } from "../../services/guildService.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import type { IInventoryChanges } from "../../types/purchaseTypes.ts";
+import { sendWsBroadcastTo } from "../../services/wsService.ts";
 
-// eslint-disable-next-line @typescript-eslint/no-misused-promises
-const createGuildController: RequestHandler = async (req, res) => {
-    const accountId = await getAccountIdForRequest(req);
-    const payload = getJSONfromString(String(req.body)) as ICreateGuildRequest;
+export const createGuildController: RequestHandler = async (req, res) => {
+    const account = await getAccountForRequest(req);
+    const payload = getJSONfromString<ICreateGuildRequest>(String(req.body));
+
+    const inventory = await getInventory(account._id.toString(), "GuildId LevelKeys Recipes");
+    if (inventory.GuildId) {
+        const guild = await Guild.findById(inventory.GuildId);
+        if (guild) {
+            res.json({
+                ...(await getGuildClient(guild, account))
+            });
+            return;
+        }
+    }
+
+    // Remove pending applications for this account
+    await GuildMember.deleteMany({ accountId: account._id, status: 1 });
 
     // Create guild on database
     const guild = new Guild({
-        Name: payload.guildName
+        Name: await createUniqueClanName(payload.guildName)
     });
     await guild.save();
 
-    // Update inventory
-    const inventory = await Inventory.findOne({ accountOwnerId: accountId });
-    if (inventory) {
-        // Set GuildId
-        inventory.GuildId = guild._id;
+    // Create guild member on database
+    await GuildMember.insertOne({
+        accountId: account._id,
+        guildId: guild._id,
+        status: 0,
+        rank: 0
+    });
 
-        // Give clan key (TODO: This should only be a blueprint)
-        inventory.LevelKeys ??= [];
-        inventory.LevelKeys.push({
-            ItemType: "/Lotus/Types/Keys/DojoKey",
-            ItemCount: 1
-        });
+    inventory.GuildId = guild._id;
+    const inventoryChanges: IInventoryChanges = {};
+    giveClanKey(inventory, inventoryChanges);
+    await inventory.save();
 
-        await inventory.save();
-    }
-
-    res.json(guild);
+    res.json({
+        ...(await getGuildClient(guild, account)),
+        InventoryChanges: inventoryChanges
+    });
+    sendWsBroadcastTo(account._id.toString(), { update_inventory: true });
 };
 
-export { createGuildController };
+interface ICreateGuildRequest {
+    guildName: string;
+}

src/controllers/api/creditsController.ts

@@ -0,0 +1,32 @@
+import type { RequestHandler } from "express";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+
+export const creditsController: RequestHandler = async (req, res) => {
+    const inventory = (
+        await Promise.all([
+            getAccountIdForRequest(req),
+            getInventory(
+                req.query.accountId as string,
+                "RegularCredits TradesRemaining PremiumCreditsFree PremiumCredits infiniteCredits infinitePlatinum"
+            )
+        ])
+    )[1];
+
+    const response = {
+        RegularCredits: inventory.RegularCredits,
+        TradesRemaining: inventory.TradesRemaining,
+        PremiumCreditsFree: inventory.PremiumCreditsFree,
+        PremiumCredits: inventory.PremiumCredits
+    };
+
+    if (inventory.infiniteCredits) {
+        response.RegularCredits = 999999999;
+    }
+    if (inventory.infinitePlatinum) {
+        response.PremiumCreditsFree = 0;
+        response.PremiumCredits = 999999999;
+    }
+
+    res.json(response);
+};

src/controllers/api/crewMembersController.ts

@@ -0,0 +1,54 @@
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import type { TInventoryDatabaseDocument } from "../../models/inventoryModels/inventoryModel.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { ICrewMemberClient } from "../../types/inventoryTypes/inventoryTypes.ts";
+import type { RequestHandler } from "express";
+import { Types } from "mongoose";
+
+export const crewMembersController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "CrewMembers NemesisHistory");
+    const data = getJSONfromString<ICrewMembersRequest>(String(req.body));
+    if (data.crewMember.SecondInCommand) {
+        clearOnCall(inventory);
+    }
+    if (data.crewMember.ItemId.$oid == "000000000000000000000000") {
+        const convertedNemesis = inventory.NemesisHistory!.find(x => x.fp == data.crewMember.NemesisFingerprint)!;
+        convertedNemesis.SecondInCommand = data.crewMember.SecondInCommand;
+    } else {
+        const dbCrewMember = inventory.CrewMembers.id(data.crewMember.ItemId.$oid)!;
+        dbCrewMember.AssignedRole = data.crewMember.AssignedRole;
+        dbCrewMember.SkillEfficiency = data.crewMember.SkillEfficiency;
+        dbCrewMember.WeaponConfigIdx = data.crewMember.WeaponConfigIdx;
+        dbCrewMember.WeaponId = new Types.ObjectId(data.crewMember.WeaponId.$oid);
+        dbCrewMember.Configs = data.crewMember.Configs;
+        dbCrewMember.SecondInCommand = data.crewMember.SecondInCommand;
+    }
+    await inventory.save();
+    res.json({
+        crewMemberId: data.crewMember.ItemId.$oid,
+        NemesisFingerprint: data.crewMember.NemesisFingerprint
+    });
+};
+
+interface ICrewMembersRequest {
+    crewMember: ICrewMemberClient;
+}
+
+const clearOnCall = (inventory: TInventoryDatabaseDocument): void => {
+    for (const cm of inventory.CrewMembers) {
+        if (cm.SecondInCommand) {
+            cm.SecondInCommand = false;
+            return;
+        }
+    }
+    if (inventory.NemesisHistory) {
+        for (const cm of inventory.NemesisHistory) {
+            if (cm.SecondInCommand) {
+                cm.SecondInCommand = false;
+                return;
+            }
+        }
+    }
+};

src/controllers/api/crewShipFusionController.ts

@@ -0,0 +1,107 @@
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { addMiscItems, freeUpSlot, getInventory, updateCurrency } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { IOid } from "../../types/commonTypes.ts";
+import type { ICrewShipComponentFingerprint } from "../../types/inventoryTypes/inventoryTypes.ts";
+import { InventorySlot } from "../../types/inventoryTypes/inventoryTypes.ts";
+import type { IInventoryChanges } from "../../types/purchaseTypes.ts";
+import type { RequestHandler } from "express";
+import { ExportCustoms, ExportDojoRecipes } from "warframe-public-export-plus";
+
+export const crewShipFusionController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId);
+    const payload = getJSONfromString<ICrewShipFusionRequest>(String(req.body));
+
+    const isWeapon = inventory.CrewShipWeapons.id(payload.PartA.$oid);
+    const itemA = isWeapon ?? inventory.CrewShipWeaponSkins.id(payload.PartA.$oid)!;
+    const category = isWeapon ? "CrewShipWeapons" : "CrewShipWeaponSkins";
+    const salvageCategory = isWeapon ? "CrewShipSalvagedWeapons" : "CrewShipSalvagedWeaponSkins";
+    const itemB = inventory[payload.SourceRecipe ? salvageCategory : category].id(payload.PartB.$oid)!;
+    const tierA = itemA.ItemType.charCodeAt(itemA.ItemType.length - 1) - 65;
+    const tierB = itemB.ItemType.charCodeAt(itemB.ItemType.length - 1) - 65;
+
+    const inventoryChanges: IInventoryChanges = {};
+
+    // Charge partial repair cost if fusing with an identified but unrepaired part
+    if (payload.SourceRecipe) {
+        const recipe = ExportDojoRecipes.research[payload.SourceRecipe];
+        updateCurrency(inventory, Math.round(recipe.price * 0.4), false, inventoryChanges);
+        const miscItemChanges = recipe.ingredients.map(x => ({ ...x, ItemCount: Math.round(x.ItemCount * -0.4) }));
+        addMiscItems(inventory, miscItemChanges);
+        inventoryChanges.MiscItems = miscItemChanges;
+    }
+
+    // Remove inferior item
+    if (payload.SourceRecipe) {
+        inventory[salvageCategory].pull({ _id: payload.PartB.$oid });
+        inventoryChanges.RemovedIdItems = [{ ItemId: payload.PartB }];
+    } else {
+        const inferiorId = tierA < tierB ? payload.PartA : payload.PartB;
+        inventory[category].pull({ _id: inferiorId.$oid });
+        inventoryChanges.RemovedIdItems = [{ ItemId: inferiorId }];
+        freeUpSlot(inventory, InventorySlot.RJ_COMPONENT_AND_ARMAMENTS);
+        inventoryChanges[InventorySlot.RJ_COMPONENT_AND_ARMAMENTS] = { count: -1, platinum: 0, Slots: 1 };
+    }
+
+    // Upgrade superior item
+    const superiorItem = tierA < tierB ? itemB : itemA;
+    const inferiorItem = tierA < tierB ? itemA : itemB;
+    const fingerprint: ICrewShipComponentFingerprint = JSON.parse(
+        superiorItem.UpgradeFingerprint!
+    ) as ICrewShipComponentFingerprint;
+    const inferiorFingerprint: ICrewShipComponentFingerprint = inferiorItem.UpgradeFingerprint
+        ? (JSON.parse(inferiorItem.UpgradeFingerprint) as ICrewShipComponentFingerprint)
+        : { compat: "", buffs: [] };
+    if (isWeapon) {
+        for (let i = 0; i != fingerprint.buffs.length; ++i) {
+            const buffA = fingerprint.buffs[i];
+            const buffB = i < inferiorFingerprint.buffs.length ? inferiorFingerprint.buffs[i] : undefined;
+            const fvalA = buffA.Value / 0x3fffffff;
+            const fvalB = (buffB?.Value ?? 0) / 0x3fffffff;
+            const percA = 0.3 + fvalA * (0.6 - 0.3);
+            const percB = 0.3 + fvalB * (0.6 - 0.3);
+            const newPerc = Math.min(0.6, Math.max(percA, percB) * FUSE_MULTIPLIERS[Math.abs(tierA - tierB)]);
+            const newFval = (newPerc - 0.3) / (0.6 - 0.3);
+            buffA.Value = Math.trunc(newFval * 0x3fffffff);
+        }
+    } else {
+        const superiorMeta = ExportCustoms[superiorItem.ItemType].randomisedUpgrades ?? [];
+        const inferiorMeta = ExportCustoms[inferiorItem.ItemType].randomisedUpgrades ?? [];
+        for (let i = 0; i != inferiorFingerprint.buffs.length; ++i) {
+            const buffA = fingerprint.buffs[i];
+            const buffB = inferiorFingerprint.buffs[i];
+            const fvalA = buffA.Value / 0x3fffffff;
+            const fvalB = buffB.Value / 0x3fffffff;
+            const rangeA = superiorMeta[i].range;
+            const rangeB = inferiorMeta[i].range;
+            const percA = rangeA[0] + fvalA * (rangeA[1] - rangeA[0]);
+            const percB = rangeB[0] + fvalB * (rangeB[1] - rangeB[0]);
+            const newPerc = Math.min(rangeA[1], Math.max(percA, percB) * FUSE_MULTIPLIERS[Math.abs(tierA - tierB)]);
+            const newFval = (newPerc - rangeA[0]) / (rangeA[1] - rangeA[0]);
+            buffA.Value = Math.trunc(newFval * 0x3fffffff);
+        }
+        if (inferiorFingerprint.SubroutineIndex !== undefined) {
+            const useSuperiorSubroutine = tierA < tierB ? !payload.UseSubroutineA : payload.UseSubroutineA;
+            if (!useSuperiorSubroutine) {
+                fingerprint.SubroutineIndex = inferiorFingerprint.SubroutineIndex;
+            }
+        }
+    }
+    superiorItem.UpgradeFingerprint = JSON.stringify(fingerprint);
+    inventoryChanges[category] = [superiorItem.toJSON() as any];
+
+    await inventory.save();
+    res.json({
+        InventoryChanges: inventoryChanges
+    });
+};
+
+interface ICrewShipFusionRequest {
+    PartA: IOid;
+    PartB: IOid;
+    SourceRecipe: string;
+    UseSubroutineA: boolean;
+}
+
+const FUSE_MULTIPLIERS = [1.1, 1.05, 1.02];

src/controllers/api/crewShipIdentifySalvageController.ts

@@ -0,0 +1,87 @@
+import {
+    addCrewShipSalvagedWeaponSkin,
+    addCrewShipRawSalvage,
+    getInventory,
+    addEquipment
+} from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { RequestHandler } from "express";
+import type {
+    ICrewShipComponentFingerprint,
+    IInnateDamageFingerprint
+} from "../../types/inventoryTypes/inventoryTypes.ts";
+import { ExportCustoms, ExportRailjackWeapons, ExportUpgrades } from "warframe-public-export-plus";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import type { IInventoryChanges } from "../../types/purchaseTypes.ts";
+import { getRandomInt } from "../../services/rngService.ts";
+import type { IFingerprintStat } from "../../helpers/rivenHelper.ts";
+import type { IEquipmentDatabase } from "../../types/equipmentTypes.ts";
+
+export const crewShipIdentifySalvageController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(
+        accountId,
+        "CrewShipSalvagedWeaponSkins CrewShipSalvagedWeapons CrewShipRawSalvage"
+    );
+    const payload = getJSONfromString<ICrewShipIdentifySalvageRequest>(String(req.body));
+
+    const inventoryChanges: IInventoryChanges = {};
+    if (payload.ItemType in ExportCustoms) {
+        const meta = ExportCustoms[payload.ItemType];
+        let upgradeFingerprint: ICrewShipComponentFingerprint = { compat: payload.ItemType, buffs: [] };
+        if (meta.subroutines) {
+            upgradeFingerprint = {
+                SubroutineIndex: getRandomInt(0, meta.subroutines.length - 1),
+                ...upgradeFingerprint
+            };
+        }
+        for (const upgrade of meta.randomisedUpgrades!) {
+            upgradeFingerprint.buffs.push({ Tag: upgrade.tag, Value: Math.trunc(Math.random() * 0x40000000) });
+        }
+        addCrewShipSalvagedWeaponSkin(
+            inventory,
+            payload.ItemType,
+            JSON.stringify(upgradeFingerprint),
+            inventoryChanges
+        );
+    } else {
+        const meta = ExportRailjackWeapons[payload.ItemType];
+        let defaultOverwrites: Partial<IEquipmentDatabase> | undefined;
+        if (meta.defaultUpgrades?.[0]) {
+            const upgradeType = meta.defaultUpgrades[0].ItemType;
+            const upgradeMeta = ExportUpgrades[upgradeType];
+            const buffs: IFingerprintStat[] = [];
+            for (const buff of upgradeMeta.upgradeEntries!) {
+                buffs.push({
+                    Tag: buff.tag,
+                    Value: Math.trunc(Math.random() * 0x40000000)
+                });
+            }
+            defaultOverwrites = {
+                UpgradeType: upgradeType,
+                UpgradeFingerprint: JSON.stringify({
+                    compat: payload.ItemType,
+                    buffs
+                } satisfies IInnateDamageFingerprint)
+            };
+        }
+        addEquipment(inventory, "CrewShipSalvagedWeapons", payload.ItemType, defaultOverwrites, inventoryChanges);
+    }
+
+    inventoryChanges.CrewShipRawSalvage = [
+        {
+            ItemType: payload.ItemType,
+            ItemCount: -1
+        }
+    ];
+    addCrewShipRawSalvage(inventory, inventoryChanges.CrewShipRawSalvage);
+
+    await inventory.save();
+    res.json({
+        InventoryChanges: inventoryChanges
+    });
+};
+
+interface ICrewShipIdentifySalvageRequest {
+    ItemType: string;
+}

src/controllers/api/customObstacleCourseLeaderboardController.ts

@@ -0,0 +1,64 @@
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { Guild } from "../../models/guildModel.ts";
+import { hasAccessToDojo, hasGuildPermission } from "../../services/guildService.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountForRequest, getAccountIdForRequest } from "../../services/loginService.ts";
+import { GuildPermission } from "../../types/guildTypes.ts";
+import { logger } from "../../utils/logger.ts";
+import type { RequestHandler } from "express";
+
+export const customObstacleCourseLeaderboardController: RequestHandler = async (req, res) => {
+    const data = getJSONfromString<ICustomObstacleCourseLeaderboardRequest>(String(req.body));
+    const guild = (await Guild.findById(data.g, "DojoComponents Ranks"))!;
+    const component = guild.DojoComponents.id(data.c)!;
+    if (req.query.act == "f") {
+        res.json({
+            results: component.Leaderboard ?? []
+        });
+    } else if (req.query.act == "p") {
+        const account = await getAccountForRequest(req);
+        component.Leaderboard ??= [];
+        const entry = component.Leaderboard.find(x => x.n == account.DisplayName);
+        if (entry) {
+            entry.s = data.s!;
+        } else {
+            component.Leaderboard.push({
+                s: data.s!,
+                n: account.DisplayName,
+                r: 0
+            });
+        }
+        component.Leaderboard.sort((a, b) => a.s - b.s); // In this case, the score is the time in milliseconds, so smaller is better.
+        if (component.Leaderboard.length > 10) {
+            component.Leaderboard.shift();
+        }
+        let r = 0;
+        for (const entry of component.Leaderboard) {
+            entry.r = ++r;
+        }
+        await guild.save();
+        res.status(200).end();
+    } else if (req.query.act == "c") {
+        // TOVERIFY: What clan permission is actually needed for this?
+        const accountId = await getAccountIdForRequest(req);
+        const inventory = await getInventory(accountId, "GuildId LevelKeys");
+        if (!hasAccessToDojo(inventory) || !(await hasGuildPermission(guild, accountId, GuildPermission.Decorator))) {
+            res.status(400).end();
+            return;
+        }
+
+        component.Leaderboard = undefined;
+        await guild.save();
+
+        res.status(200).end();
+    } else {
+        logger.debug(`data provided to ${req.path}: ${String(req.body)}`);
+        throw new Error(`unknown customObstacleCourseLeaderboard act: ${String(req.query.act)}`);
+    }
+};
+
+interface ICustomObstacleCourseLeaderboardRequest {
+    g: string;
+    c: string;
+    s?: number; // act=p
+}

src/controllers/api/customizeGuildRanksController.ts

@@ -0,0 +1,22 @@
+import { getGuildForRequest, hasGuildPermission } from "../../services/guildService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { IGuildRank } from "../../types/guildTypes.ts";
+import { GuildPermission } from "../../types/guildTypes.ts";
+import type { RequestHandler } from "express";
+
+export const customizeGuildRanksController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const guild = await getGuildForRequest(req);
+    const payload = JSON.parse(String(req.body)) as ICustomizeGuildRanksRequest;
+    if (!(await hasGuildPermission(guild, accountId, GuildPermission.Ruler))) {
+        res.status(400).json("Invalid permission");
+        return;
+    }
+    guild.Ranks = payload.GuildRanks;
+    await guild.save();
+    res.end();
+};
+
+interface ICustomizeGuildRanksRequest {
+    GuildRanks: IGuildRank[];
+}

src/controllers/api/declineAllianceInviteController.ts

@@ -0,0 +1,17 @@
+import { AllianceMember, GuildMember } from "../../models/guildModel.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { RequestHandler } from "express";
+
+export const declineAllianceInviteController: RequestHandler = async (req, res) => {
+    // Check requester is a warlord in their guild
+    const accountId = await getAccountIdForRequest(req);
+    const guildMember = (await GuildMember.findOne({ accountId, status: 0 }))!;
+    if (guildMember.rank > 1) {
+        res.status(400).json({ Error: 104 });
+        return;
+    }
+
+    await AllianceMember.deleteOne({ allianceId: req.query.allianceId, guildId: guildMember.guildId });
+
+    res.end();
+};

src/controllers/api/declineGuildInviteController.ts

@@ -0,0 +1,14 @@
+import { GuildMember } from "../../models/guildModel.ts";
+import { getAccountForRequest } from "../../services/loginService.ts";
+import type { RequestHandler } from "express";
+
+export const declineGuildInviteController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountForRequest(req);
+
+    await GuildMember.deleteOne({
+        accountId: accountId,
+        guildId: req.query.clanId as string
+    });
+
+    res.end();
+};

src/controllers/api/deleteSessionController.ts

@@ -1,9 +1,17 @@
-import { RequestHandler } from "express";
-import { deleteSession } from "@/src/managers/sessionManager";
+import type { RequestHandler } from "express";
+import { deleteSession } from "../../managers/sessionManager.ts";
+import { getAccountForRequest } from "../../services/loginService.ts";
+import { version_compare } from "../../helpers/inventoryHelpers.ts";
 
-const deleteSessionController: RequestHandler = (_req, res) => {
+const deleteSessionController: RequestHandler = async (_req, res) => {
+    const account = await getAccountForRequest(_req);
     deleteSession(_req.query.sessionId as string);
-    res.sendStatus(200);
+    if (account.BuildLabel && version_compare(account.BuildLabel, "2016.07.08.16.56") < 0) {
+        // Pre-Specters of the Rail
+        res.send(_req.query.sessionId as string); // Unsure if this is correct, but the client is chill with it
+    } else {
+        res.sendStatus(200);
+    }
 };
 
 export { deleteSessionController };

src/controllers/api/destroyDojoDecoController.ts

@@ -0,0 +1,51 @@
+import {
+    getDojoClient,
+    getGuildForRequestEx,
+    hasAccessToDojo,
+    hasGuildPermission,
+    refundDojoDeco,
+    removeDojoDeco
+} from "../../services/guildService.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { GuildPermission } from "../../types/guildTypes.ts";
+import { logger } from "../../utils/logger.ts";
+import type { RequestHandler } from "express";
+
+export const destroyDojoDecoController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "GuildId LevelKeys");
+    const guild = await getGuildForRequestEx(req, inventory);
+    if (!hasAccessToDojo(inventory) || !(await hasGuildPermission(guild, accountId, GuildPermission.Decorator))) {
+        res.json({ DojoRequestStatus: -1 });
+        return;
+    }
+    const request = JSON.parse(String(req.body)) as IDestroyDojoDecoRequest | IClearObstacleCourseRequest;
+    if ("DecoType" in request) {
+        removeDojoDeco(guild, request.ComponentId, request.DecoId);
+    } else if (request.Act == "cObst") {
+        const component = guild.DojoComponents.id(request.ComponentId)!;
+        if (component.Decos) {
+            for (const deco of component.Decos) {
+                refundDojoDeco(guild, component, deco);
+            }
+            component.Decos.splice(0, component.Decos.length);
+        }
+    } else {
+        logger.error(`unhandled destroyDojoDeco request`, request);
+    }
+
+    await guild.save();
+    res.json(await getDojoClient(guild, 0, request.ComponentId));
+};
+
+interface IDestroyDojoDecoRequest {
+    DecoType: string;
+    ComponentId: string;
+    DecoId: string;
+}
+
+interface IClearObstacleCourseRequest {
+    ComponentId: string;
+    Act: "cObst" | "maybesomethingelsewedontknowabout";
+}

src/controllers/api/divvyAllianceVaultController.ts

@@ -0,0 +1,67 @@
+import { Alliance, AllianceMember, Guild, GuildMember } from "../../models/guildModel.ts";
+import { getAccountForRequest } from "../../services/loginService.ts";
+import { GuildPermission } from "../../types/guildTypes.ts";
+import { parallelForeach } from "../../utils/async-utils.ts";
+import { logger } from "../../utils/logger.ts";
+import type { RequestHandler } from "express";
+
+export const divvyAllianceVaultController: RequestHandler = async (req, res) => {
+    // Afaict, there's no way to put anything other than credits in the alliance vault (anymore?), so just no-op if this is not a request to divvy credits.
+    if (req.query.credits == "1") {
+        // Check requester is a warlord in their guild
+        const account = await getAccountForRequest(req);
+        const guildMember = (await GuildMember.findOne({ accountId: account._id, status: 0 }))!;
+        if (guildMember.rank > 1) {
+            res.status(400).end();
+            return;
+        }
+
+        // Check guild has treasurer permissions in the alliance
+        const allianceMember = (await AllianceMember.findOne({
+            allianceId: req.query.allianceId,
+            guildId: guildMember.guildId
+        }))!;
+        if (!(allianceMember.Permissions & GuildPermission.Treasurer)) {
+            res.status(400).end();
+            return;
+        }
+
+        const allianceMembers = await AllianceMember.find({ allianceId: req.query.allianceId });
+        const memberCounts: Record<string, number> = {};
+        let totalMembers = 0;
+        await parallelForeach(allianceMembers, async allianceMember => {
+            const memberCount = await GuildMember.countDocuments({
+                guildId: allianceMember.guildId
+            });
+            memberCounts[allianceMember.guildId.toString()] = memberCount;
+            totalMembers += memberCount;
+        });
+        logger.debug(`alliance has ${totalMembers} members between all its clans`);
+
+        const alliance = (await Alliance.findById(allianceMember.allianceId, "VaultRegularCredits"))!;
+        if (alliance.VaultRegularCredits) {
+            let creditsHandedOutInTotal = 0;
+            await parallelForeach(allianceMembers, async allianceMember => {
+                const memberCount = memberCounts[allianceMember.guildId.toString()];
+                const cutPercentage = memberCount / totalMembers;
+                const creditsToHandOut = Math.trunc(alliance.VaultRegularCredits! * cutPercentage);
+                logger.debug(
+                    `${allianceMember.guildId.toString()} has ${memberCount} member(s) = ${Math.trunc(cutPercentage * 100)}% of alliance; giving ${creditsToHandOut} credit(s)`
+                );
+                if (creditsToHandOut != 0) {
+                    await Guild.updateOne(
+                        { _id: allianceMember.guildId },
+                        { $inc: { VaultRegularCredits: creditsToHandOut } }
+                    );
+                    creditsHandedOutInTotal += creditsToHandOut;
+                }
+            });
+            alliance.VaultRegularCredits -= creditsHandedOutInTotal;
+            logger.debug(
+                `handed out ${creditsHandedOutInTotal} credits; alliance vault now has ${alliance.VaultRegularCredits} credit(s)`
+            );
+        }
+        await alliance.save();
+    }
+    res.end();
+};

src/controllers/api/dojoComponentRushController.ts

@@ -0,0 +1,83 @@
+import type { TGuildDatabaseDocument } from "../../models/guildModel.ts";
+import { GuildMember } from "../../models/guildModel.ts";
+import {
+    getDojoClient,
+    getGuildForRequestEx,
+    hasAccessToDojo,
+    scaleRequiredCount
+} from "../../services/guildService.ts";
+import { getInventory, updateCurrency } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { IDojoContributable } from "../../types/guildTypes.ts";
+import type { RequestHandler } from "express";
+import type { IDojoBuild } from "warframe-public-export-plus";
+import { ExportDojoRecipes } from "warframe-public-export-plus";
+
+interface IDojoComponentRushRequest {
+    DecoType?: string;
+    DecoId?: string;
+    ComponentId: string;
+    Amount: number;
+    VaultAmount: number;
+    AllianceVaultAmount: number;
+}
+
+export const dojoComponentRushController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId);
+    if (!hasAccessToDojo(inventory)) {
+        res.json({ DojoRequestStatus: -1 });
+        return;
+    }
+    const guild = await getGuildForRequestEx(req, inventory);
+    const request = JSON.parse(String(req.body)) as IDojoComponentRushRequest;
+    const component = guild.DojoComponents.id(request.ComponentId)!;
+
+    let platinumDonated = request.Amount;
+    const inventoryChanges = updateCurrency(inventory, request.Amount, true);
+    if (request.VaultAmount) {
+        platinumDonated += request.VaultAmount;
+        guild.VaultPremiumCredits! -= request.VaultAmount;
+    }
+
+    if (request.DecoId) {
+        const deco = component.Decos!.find(x => x._id.equals(request.DecoId))!;
+        const meta = Object.values(ExportDojoRecipes.decos).find(x => x.resultType == deco.Type)!;
+        processContribution(guild, deco, meta, platinumDonated);
+    } else {
+        const meta = Object.values(ExportDojoRecipes.rooms).find(x => x.resultType == component.pf)!;
+        processContribution(guild, component, meta, platinumDonated);
+
+        const entry = guild.RoomChanges?.find(x => x.componentId.equals(component._id));
+        if (entry) {
+            entry.dateTime = component.CompletionTime!;
+        }
+    }
+
+    const guildMember = (await GuildMember.findOne({ accountId, guildId: guild._id }, "PremiumCreditsContributed"))!;
+    guildMember.PremiumCreditsContributed ??= 0;
+    guildMember.PremiumCreditsContributed += request.Amount;
+
+    await Promise.all([guild.save(), inventory.save(), guildMember.save()]);
+
+    res.json({
+        ...(await getDojoClient(guild, 0, component._id)),
+        InventoryChanges: inventoryChanges
+    });
+};
+
+const processContribution = (
+    guild: TGuildDatabaseDocument,
+    component: IDojoContributable,
+    meta: IDojoBuild,
+    platinumDonated: number
+): void => {
+    const fullPlatinumCost = scaleRequiredCount(guild.Tier, meta.skipTimePrice);
+    const fullDurationSeconds = meta.time;
+    const secondsPerPlatinum = fullDurationSeconds / fullPlatinumCost;
+    component.CompletionTime = new Date(
+        component.CompletionTime!.getTime() - secondsPerPlatinum * platinumDonated * 1000
+    );
+    component.RushPlatinum ??= 0;
+    component.RushPlatinum += platinumDonated;
+};

src/controllers/api/dojoController.ts

@@ -1,5 +1,11 @@
-import { RequestHandler } from "express";
+import type { RequestHandler } from "express";
+
+// Arbiter Dojo endpoints, not really used by us as we don't provide a ContentURL.
 
 export const dojoController: RequestHandler = (_req, res) => {
     res.json("-1"); // Tell client to use authorised request.
 };
+
+export const setDojoURLController: RequestHandler = (_req, res) => {
+    res.end();
+};

src/controllers/api/dronesController.ts

@@ -1,7 +1,145 @@
-import { RequestHandler } from "express";
+import { toMongoDate, toOid } from "../../helpers/inventoryHelpers.ts";
+import { addMiscItems, getInventory } from "../../services/inventoryService.ts";
+import { fromStoreItem } from "../../services/itemDataService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { getRandomInt, getRandomWeightedRewardUc } from "../../services/rngService.ts";
+import type { IMongoDate, IOid } from "../../types/commonTypes.ts";
+import type { IDroneClient } from "../../types/inventoryTypes/inventoryTypes.ts";
+import type { IInventoryChanges } from "../../types/purchaseTypes.ts";
+import type { RequestHandler } from "express";
+import { ExportDrones, ExportResources, ExportSystems } from "warframe-public-export-plus";
 
-const dronesController: RequestHandler = (_req, res) => {
-    res.json({});
+export const dronesController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    if ("GetActive" in req.query) {
+        const inventory = await getInventory(accountId, "Drones");
+        const activeDrones: IActiveDrone[] = [];
+        for (const drone of inventory.Drones) {
+            if (drone.DeployTime) {
+                activeDrones.push({
+                    DeployTime: toMongoDate(drone.DeployTime),
+                    System: drone.System!,
+                    ItemId: toOid(drone._id),
+                    ItemType: drone.ItemType,
+                    CurrentHP: drone.CurrentHP,
+                    DamageTime: toMongoDate(drone.DamageTime!),
+                    PendingDamage: drone.PendingDamage!,
+                    Resources: [
+                        {
+                            ItemType: drone.ResourceType!,
+                            BinTotal: drone.ResourceCount!,
+                            StartTime: toMongoDate(drone.DeployTime)
+                        }
+                    ]
+                });
+            }
+        }
+        res.json({
+            ActiveDrones: activeDrones
+        });
+    } else if ("droneId" in req.query && "systemIndex" in req.query) {
+        const inventory = await getInventory(
+            accountId,
+            "Drones instantResourceExtractorDrones noResourceExtractorDronesDamage"
+        );
+        const drone = inventory.Drones.id(req.query.droneId as string)!;
+        const droneMeta = ExportDrones[drone.ItemType];
+        drone.DeployTime = inventory.instantResourceExtractorDrones ? new Date(0) : new Date();
+        if (drone.RepairStart) {
+            const repairMinutes = (Date.now() - drone.RepairStart.getTime()) / 60_000;
+            const hpPerMinute = droneMeta.repairRate / 60;
+            drone.CurrentHP = Math.min(drone.CurrentHP + Math.round(repairMinutes * hpPerMinute), droneMeta.durability);
+            drone.RepairStart = undefined;
+        }
+        drone.System = parseInt(req.query.systemIndex as string);
+        const system = ExportSystems[drone.System - 1];
+        drone.DamageTime = inventory.instantResourceExtractorDrones
+            ? new Date()
+            : new Date(Date.now() + getRandomInt(3 * 3600 * 1000, 4 * 3600 * 1000));
+        drone.PendingDamage =
+            !inventory.noResourceExtractorDronesDamage && Math.random() < system.damageChance
+                ? getRandomInt(system.droneDamage.minValue, system.droneDamage.maxValue)
+                : 0;
+        const resource = getRandomWeightedRewardUc(system.resources, droneMeta.probabilities)!;
+        //logger.debug(`drone rolled`, resource);
+        drone.ResourceType = fromStoreItem(resource.StoreItem);
+        const resourceMeta = ExportResources[drone.ResourceType];
+        if (resourceMeta.pickupQuantity) {
+            const pickupsToCollect = droneMeta.binCapacity * droneMeta.capacityMultipliers[resource.Rarity];
+            drone.ResourceCount = 0;
+            for (let i = 0; i != pickupsToCollect; ++i) {
+                drone.ResourceCount += getRandomInt(
+                    resourceMeta.pickupQuantity.minValue,
+                    resourceMeta.pickupQuantity.maxValue
+                );
+            }
+        } else {
+            drone.ResourceCount = droneMeta.binCapacity * droneMeta.capacityMultipliers[resource.Rarity];
+        }
+        await inventory.save();
+        res.json({});
+    } else if ("collectDroneId" in req.query) {
+        const inventory = await getInventory(accountId);
+        const drone = inventory.Drones.id(req.query.collectDroneId as string)!;
+
+        if (new Date() >= drone.DamageTime!) {
+            drone.CurrentHP -= drone.PendingDamage!;
+            drone.RepairStart = new Date();
+        }
+
+        const inventoryChanges: IInventoryChanges = {};
+        if (drone.CurrentHP <= 0) {
+            inventory.RegularCredits += 100;
+            inventoryChanges.RegularCredits = 100;
+            inventory.Drones.pull({ _id: req.query.collectDroneId as string });
+            inventoryChanges.RemovedIdItems = [
+                {
+                    ItemId: { $oid: req.query.collectDroneId }
+                }
+            ];
+        } else {
+            const completionTime = drone.DeployTime!.getTime() + ExportDrones[drone.ItemType].fillRate * 3600_000;
+            if (Date.now() >= completionTime) {
+                const miscItemChanges = [
+                    {
+                        ItemType: drone.ResourceType!,
+                        ItemCount: drone.ResourceCount!
+                    }
+                ];
+                addMiscItems(inventory, miscItemChanges);
+                inventoryChanges.MiscItems = miscItemChanges;
+            }
+
+            drone.DeployTime = undefined;
+            drone.System = undefined;
+            drone.DamageTime = undefined;
+            drone.PendingDamage = undefined;
+            drone.ResourceType = undefined;
+            drone.ResourceCount = undefined;
+
+            inventoryChanges.Drones = [drone.toJSON<IDroneClient>()];
+        }
+
+        await inventory.save();
+        res.json({
+            InventoryChanges: inventoryChanges
+        });
+    } else {
+        throw new Error(`drones.php query not handled`);
+    }
 };
 
-export { dronesController };
+interface IActiveDrone {
+    DeployTime: IMongoDate;
+    System: number;
+    ItemId: IOid;
+    ItemType: string;
+    CurrentHP: number;
+    DamageTime: IMongoDate;
+    PendingDamage: number;
+    Resources: {
+        ItemType: string;
+        BinTotal: number;
+        StartTime: IMongoDate;
+    }[];
+}

src/controllers/api/endlessXpController.ts

@@ -0,0 +1,534 @@
+import type { RequestHandler } from "express";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { combineInventoryChanges, getInventory } from "../../services/inventoryService.ts";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import type {
+    IEndlessXpReward,
+    IInventoryClient,
+    TEndlessXpCategory
+} from "../../types/inventoryTypes/inventoryTypes.ts";
+import { logger } from "../../utils/logger.ts";
+import type { ICountedStoreItem } from "warframe-public-export-plus";
+import { ExportRewards } from "warframe-public-export-plus";
+import { getRandomElement } from "../../services/rngService.ts";
+import { handleStoreItemAcquisition } from "../../services/purchaseService.ts";
+import type { IInventoryChanges } from "../../types/purchaseTypes.ts";
+
+export const endlessXpController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const payload = getJSONfromString<IEndlessXpRequest>(String(req.body));
+    if (payload.Mode == "r") {
+        const inventory = await getInventory(accountId, "EndlessXP");
+        inventory.EndlessXP ??= [];
+        let entry = inventory.EndlessXP.find(x => x.Category == payload.Category);
+        if (!entry) {
+            entry = {
+                Category: payload.Category,
+                Earn: 0,
+                Claim: 0,
+                Choices: payload.Choices,
+                PendingRewards: []
+            };
+            inventory.EndlessXP.push(entry);
+        }
+
+        const weekStart = 1734307200_000 + Math.trunc((Date.now() - 1734307200_000) / 604800000) * 604800000;
+        const weekEnd = weekStart + 604800000;
+
+        entry.Earn = 0;
+        entry.Claim = 0;
+        entry.BonusAvailable = new Date(weekStart);
+        entry.Expiry = new Date(weekEnd);
+        entry.Choices = payload.Choices;
+        entry.PendingRewards =
+            payload.Category == "EXC_HARD"
+                ? generateHardModeRewards(payload.Choices)
+                : generateNormalModeRewards(payload.Choices);
+
+        await inventory.save();
+        res.json({
+            NewProgress: inventory.toJSON<IInventoryClient>().EndlessXP!.find(x => x.Category == payload.Category)!
+        });
+    } else if (payload.Mode == "c") {
+        const inventory = await getInventory(accountId);
+        const entry = inventory.EndlessXP!.find(x => x.Category == payload.Category)!;
+        const inventoryChanges: IInventoryChanges = {};
+        for (const reward of entry.PendingRewards) {
+            if (entry.Claim < reward.RequiredTotalXp && reward.RequiredTotalXp <= entry.Earn) {
+                combineInventoryChanges(
+                    inventoryChanges,
+                    (
+                        await handleStoreItemAcquisition(
+                            reward.Rewards[0].StoreItem,
+                            inventory,
+                            reward.Rewards[0].ItemCount
+                        )
+                    ).InventoryChanges
+                );
+            }
+        }
+        entry.Claim = entry.Earn;
+        await inventory.save();
+        res.json({
+            InventoryChanges: inventoryChanges,
+            ClaimedXp: entry.Claim
+        });
+    } else {
+        logger.debug(`data provided to ${req.path}: ${String(req.body)}`);
+        throw new Error(`unexpected endlessXp mode: ${payload.Mode}`);
+    }
+};
+
+type IEndlessXpRequest =
+    | {
+          Mode: "r";
+          Category: TEndlessXpCategory;
+          Choices: string[];
+      }
+    | {
+          Mode: "c" | "something else";
+          Category: TEndlessXpCategory;
+      };
+
+const generateRandomRewards = (deckName: string): ICountedStoreItem[] => {
+    const reward = getRandomElement(ExportRewards[deckName][0])!;
+    return [
+        {
+            StoreItem: reward.type,
+            ItemCount: reward.itemCount
+        }
+    ];
+};
+
+const normalModeChosenRewards: Record<string, string[]> = {
+    Excalibur: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/ExcaliburHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/ExcaliburChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Excalibur/RadialJavelinAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/ExcaliburSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/ExcaliburBlueprint"
+    ],
+    Trinity: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/TrinityHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/TrinityChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Trinity/EnergyVampireAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/TrinitySystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/TrinityBlueprint"
+    ],
+    Ember: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/EmberHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/EmberChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Ember/WorldOnFireAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/EmberSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/EmberBlueprint"
+    ],
+    Loki: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/LOKIHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/LOKIChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Loki/InvisibilityAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/LOKISystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/LOKIBlueprint"
+    ],
+    Mag: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/MagHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/MagChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Mag/CrushAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/MagSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/MagBlueprint"
+    ],
+    Rhino: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/RhinoHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/RhinoChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Rhino/RhinoChargeAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/RhinoSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/RhinoBlueprint"
+    ],
+    Ash: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/AshHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/AshChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Ninja/GlaiveAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/AshSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/AshBlueprint"
+    ],
+    Frost: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/FrostHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/FrostChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Frost/IceShieldAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/FrostSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/FrostBlueprint"
+    ],
+    Nyx: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NyxHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NyxChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Jade/SelfBulletAttractorAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NyxSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NyxBlueprint"
+    ],
+    Saryn: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/SarynHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/SarynChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Saryn/PoisonAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/SarynSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/SarynBlueprint"
+    ],
+    Vauban: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/TrapperHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/TrapperChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Trapper/LevTrapAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/TrapperSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/TrapperBlueprint"
+    ],
+    Nova: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NovaHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NovaChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/AntiMatter/MolecularPrimeAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NovaSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NovaBlueprint"
+    ],
+    Nekros: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NecroHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NecroChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Necro/CloneTheDeadAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NecroSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NecroBlueprint"
+    ],
+    Valkyr: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/BerserkerHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/BerserkerChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Berserker/IntimidateAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/BerserkerSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/BerserkerBlueprint"
+    ],
+    Oberon: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/PaladinHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/PaladinChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Paladin/RegenerationAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/PaladinSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/PaladinBlueprint"
+    ],
+    Hydroid: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/HydroidHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/HydroidChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Pirate/CannonBarrageAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/HydroidSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/HydroidBlueprint"
+    ],
+    Mirage: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/HarlequinHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/HarlequinChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Harlequin/LightAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/HarlequinSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/HarlequinBlueprint"
+    ],
+    Limbo: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/MagicianHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/MagicianChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Magician/TearInSpaceAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/MagicianSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/MagicianBlueprint"
+    ],
+    Mesa: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/GunslingerHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/GunslingerChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Cowgirl/GunFuPvPAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/GunslingerSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/GunslingerBlueprint"
+    ],
+    Chroma: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/ChromaHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/ChromaChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Dragon/DragonLuckAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/ChromaSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/ChromaBlueprint"
+    ],
+    Atlas: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/BrawlerHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/BrawlerChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Brawler/BrawlerPassiveAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/BrawlerSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/BrawlerBlueprint"
+    ],
+    Ivara: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/RangerHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/RangerChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Ranger/RangerStealAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/RangerSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/RangerBlueprint"
+    ],
+    Inaros: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/MummyHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/MummyChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Sandman/SandmanSwarmAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/MummySystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/MummyBlueprint"
+    ],
+    Titania: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/FairyHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/FairyChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Fairy/FairyFlightAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/FairySystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/FairyBlueprint"
+    ],
+    Nidus: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NidusHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NidusChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Infestation/InfestPodsAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NidusSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/NidusBlueprint"
+    ],
+    Octavia: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/OctaviaHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/OctaviaChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Bard/BardCharmAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/OctaviaSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/OctaviaBlueprint"
+    ],
+    Harrow: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/PriestHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/PriestChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Priest/PriestPactAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/PriestSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/PriestBlueprint"
+    ],
+    Gara: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/GlassHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/GlassChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Glass/GlassFragmentAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/GlassSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/GlassBlueprint"
+    ],
+    Khora: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/KhoraHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/KhoraChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Khora/KhoraCrackAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/KhoraSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/KhoraBlueprint"
+    ],
+    Revenant: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/RevenantHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/RevenantChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Revenant/RevenantMarkAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/RevenantSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/RevenantBlueprint"
+    ],
+    Garuda: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/GarudaHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/GarudaChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Garuda/GarudaUnstoppableAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/GarudaSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/GarudaBlueprint"
+    ],
+    Baruuk: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/PacifistHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/PacifistChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/Pacifist/PacifistFistAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/PacifistSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/PacifistBlueprint"
+    ],
+    Hildryn: [
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/IronframeHelmetBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/IronframeChassisBlueprint",
+        "/Lotus/StoreItems/Powersuits/IronFrame/IronFrameStripAugmentCard",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/IronframeSystemsBlueprint",
+        "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/IronframeBlueprint"
+    ]
+};
+
+const generateNormalModeRewards = (choices: string[]): IEndlessXpReward[] => {
+    const choiceRewards = normalModeChosenRewards[choices[0]];
+    return [
+        {
+            RequiredTotalXp: 190,
+            Rewards: generateRandomRewards(
+                "/Lotus/Types/Game/MissionDecks/DuviriEndlessCircuitRewards/DuviriEndlessNormalSilverRewards"
+            )
+        },
+        {
+            RequiredTotalXp: 400,
+            Rewards: [
+                {
+                    StoreItem: choiceRewards[0],
+                    ItemCount: 1
+                }
+            ]
+        },
+        {
+            RequiredTotalXp: 630,
+            Rewards: generateRandomRewards(
+                "/Lotus/Types/Game/MissionDecks/DuviriEndlessCircuitRewards/DuviriEndlessNormalSilverRewards"
+            )
+        },
+        {
+            RequiredTotalXp: 890,
+            Rewards: generateRandomRewards(
+                "/Lotus/Types/Game/MissionDecks/DuviriEndlessCircuitRewards/DuviriEndlessNormalMODRewards"
+            )
+        },
+        {
+            RequiredTotalXp: 1190,
+            Rewards: [
+                {
+                    StoreItem: choiceRewards[1],
+                    ItemCount: 1
+                }
+            ]
+        },
+        {
+            RequiredTotalXp: 1540,
+            Rewards: generateRandomRewards(
+                "/Lotus/Types/Game/MissionDecks/DuviriEndlessCircuitRewards/DuviriEndlessNormalGoldRewards"
+            )
+        },
+        {
+            RequiredTotalXp: 1950,
+            Rewards: [
+                {
+                    StoreItem: choiceRewards[2],
+                    ItemCount: 1
+                }
+            ]
+        },
+        {
+            RequiredTotalXp: 2430,
+            Rewards: [
+                {
+                    StoreItem: choiceRewards[3],
+                    ItemCount: 1
+                }
+            ]
+        },
+        {
+            RequiredTotalXp: 2990,
+            Rewards: generateRandomRewards(
+                "/Lotus/Types/Game/MissionDecks/DuviriEndlessCircuitRewards/DuviriEndlessNormalArcaneRewards"
+            )
+        },
+        {
+            RequiredTotalXp: 3640,
+            Rewards: [
+                {
+                    StoreItem: choiceRewards[4],
+                    ItemCount: 1
+                }
+            ]
+        }
+    ];
+};
+
+const hardModeChosenRewards: Record<string, string> = {
+    Braton: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Primary/BratonIncarnonUnlocker",
+    Lato: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Secondary/LatoIncarnonUnlocker",
+    Skana: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Melee/SkanaIncarnonUnlocker",
+    Paris: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Primary/ParisIncarnonUnlocker",
+    Kunai: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Secondary/KunaiIncarnonUnlocker",
+    Boar: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Primary/BoarIncarnonUnlocker",
+    Gammacor: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Secondary/GammacorIncarnonUnlocker",
+    Anku: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Melee/AnkuIncarnonUnlocker",
+    Gorgon: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Primary/GorgonIncarnonUnlocker",
+    Angstrum: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Secondary/AngstrumIncarnonUnlocker",
+    Bo: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Melee/BoIncarnonUnlocker",
+    Latron: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Primary/LatronIncarnonUnlocker",
+    Furis: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Secondary/FurisIncarnonUnlocker",
+    Furax: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Melee/FuraxIncarnonUnlocker",
+    Strun: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Primary/StrunIncarnonUnlocker",
+    Lex: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Secondary/LexIncarnonUnlocker",
+    Magistar: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Melee/MagistarIncarnonUnlocker",
+    Boltor: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Primary/BoltorIncarnonUnlocker",
+    Bronco: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Secondary/BroncoIncarnonUnlocker",
+    CeramicDagger: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Melee/CeramicDaggerIncarnonUnlocker",
+    Torid: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Primary/ToridIncarnonUnlocker",
+    DualToxocyst: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Secondary/DualToxocystIncarnonUnlocker",
+    DualIchor: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Melee/DualIchorIncarnonUnlocker",
+    Miter: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Primary/MiterIncarnonUnlocker",
+    Atomos: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Secondary/AtomosIncarnonUnlocker",
+    AckAndBrunt: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Melee/AckAndBruntIncarnonUnlocker",
+    Soma: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Primary/SomaIncarnonUnlocker",
+    Vasto: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Secondary/VastoIncarnonUnlocker",
+    NamiSolo: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Melee/NamiSoloIncarnonUnlocker",
+    Burston: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Primary/BurstonIncarnonUnlocker",
+    Zylok: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Secondary/ZylokIncarnonUnlocker",
+    Sibear: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Melee/SibearIncarnonUnlocker",
+    Dread: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Primary/DreadIncarnonUnlocker",
+    Despair: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Secondary/DespairIncarnonUnlocker",
+    Hate: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Melee/HateIncarnonUnlocker",
+    Dera: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Primary/DeraIncarnonUnlocker",
+    Cestra: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Secondary/CestraIncarnonUnlocker",
+    Okina: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Melee/OkinaIncarnonUnlocker",
+    Sybaris: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Primary/SybarisIncarnonUnlocker",
+    Sicarus: "/Lotus/StoreItems/Types/Items/MiscItems/IncarnonAdapters/Secondary/SicarusIncarnonUnlocker",
+    RivenPrimary: "/Lotus/StoreItems/Upgrades/Mods/Randomized/RawRifleRandomMod",
+    RivenSecondary: "/Lotus/StoreItems/Upgrades/Mods/Randomized/RawPistolRandomMod",
+    RivenMelee: "/Lotus/StoreItems/Upgrades/Mods/Randomized/RawMeleeRandomMod",
+    Kuva: "/Lotus/Types/Game/DuviriEndless/CircuitSteelPathBIGKuvaReward"
+};
+
+const generateHardModeRewards = (choices: string[]): IEndlessXpReward[] => {
+    return [
+        {
+            RequiredTotalXp: 285,
+            Rewards: generateRandomRewards(
+                "/Lotus/Types/Game/MissionDecks/DuviriEndlessCircuitRewards/DuviriEndlessSteelPathSilverRewards"
+            )
+        },
+        {
+            RequiredTotalXp: 600,
+            Rewards: generateRandomRewards(
+                "/Lotus/Types/Game/MissionDecks/DuviriEndlessCircuitRewards/DuviriEndlessSteelPathArcaneRewards"
+            )
+        },
+        {
+            RequiredTotalXp: 945,
+            Rewards: generateRandomRewards(
+                "/Lotus/Types/Game/MissionDecks/DuviriEndlessCircuitRewards/DuviriEndlessSteelPathSilverRewards"
+            )
+        },
+        {
+            RequiredTotalXp: 1335,
+            Rewards: generateRandomRewards(
+                "/Lotus/Types/Game/MissionDecks/DuviriEndlessCircuitRewards/DuviriEndlessSteelPathSilverRewards"
+            )
+        },
+        {
+            RequiredTotalXp: 1785,
+            Rewards: [
+                {
+                    StoreItem: hardModeChosenRewards[choices[0]],
+                    ItemCount: 1
+                }
+            ]
+        },
+        {
+            RequiredTotalXp: 2310,
+            Rewards: generateRandomRewards(
+                "/Lotus/Types/Game/MissionDecks/DuviriEndlessCircuitRewards/DuviriEndlessSteelPathGoldRewards"
+            )
+        },
+        {
+            RequiredTotalXp: 2925,
+            Rewards: generateRandomRewards(
+                "/Lotus/Types/Game/MissionDecks/DuviriEndlessCircuitRewards/DuviriEndlessSteelPathGoldRewards"
+            )
+        },
+        {
+            RequiredTotalXp: 3645,
+            Rewards: generateRandomRewards(
+                "/Lotus/Types/Game/MissionDecks/DuviriEndlessCircuitRewards/DuviriEndlessSteelPathArcaneRewards"
+            )
+        },
+        {
+            RequiredTotalXp: 4485,
+            Rewards: generateRandomRewards(
+                "/Lotus/Types/Game/MissionDecks/DuviriEndlessCircuitRewards/DuviriEndlessSteelPathSteelEssenceRewards"
+            )
+        },
+        {
+            RequiredTotalXp: 5460,
+            Rewards: [
+                {
+                    StoreItem: hardModeChosenRewards[choices[1]],
+                    ItemCount: 1
+                }
+            ]
+        }
+    ];
+};

src/controllers/api/entratiLabConquestModeController.ts

@@ -0,0 +1,52 @@
+import { toMongoDate } from "../../helpers/inventoryHelpers.ts";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { getInventory, updateEntratiVault } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { RequestHandler } from "express";
+
+export const entratiLabConquestModeController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(
+        accountId,
+        "EntratiVaultCountResetDate EntratiVaultCountLastPeriod EntratiLabConquestUnlocked EchoesHexConquestUnlocked EchoesHexConquestActiveFrameVariants EchoesHexConquestActiveStickers EntratiLabConquestActiveFrameVariants EntratiLabConquestCacheScoreMission EchoesHexConquestCacheScoreMission"
+    );
+    const body = getJSONfromString<IEntratiLabConquestModeRequest>(String(req.body));
+    updateEntratiVault(inventory);
+    if (body.BuyMode) {
+        inventory.EntratiVaultCountLastPeriod! += 2;
+        if (body.IsEchoesDeepArchemedea) {
+            inventory.EchoesHexConquestUnlocked = 1;
+        } else {
+            inventory.EntratiLabConquestUnlocked = 1;
+        }
+    }
+    if (body.IsEchoesDeepArchemedea) {
+        if (inventory.EchoesHexConquestUnlocked) {
+            inventory.EchoesHexConquestActiveFrameVariants = body.EchoesHexConquestActiveFrameVariants!;
+            inventory.EchoesHexConquestActiveStickers = body.EchoesHexConquestActiveStickers!;
+        }
+    } else {
+        if (inventory.EntratiLabConquestUnlocked) {
+            inventory.EntratiLabConquestActiveFrameVariants = body.EntratiLabConquestActiveFrameVariants!;
+        }
+    }
+    await inventory.save();
+    res.json({
+        EntratiVaultCountResetDate: toMongoDate(inventory.EntratiVaultCountResetDate!),
+        EntratiVaultCountLastPeriod: inventory.EntratiVaultCountLastPeriod,
+        EntratiLabConquestUnlocked: inventory.EntratiLabConquestUnlocked,
+        EntratiLabConquestCacheScoreMission: inventory.EntratiLabConquestCacheScoreMission,
+        EchoesHexConquestUnlocked: inventory.EchoesHexConquestUnlocked,
+        EchoesHexConquestCacheScoreMission: inventory.EchoesHexConquestCacheScoreMission
+    });
+};
+
+interface IEntratiLabConquestModeRequest {
+    BuyMode?: number;
+    IsEchoesDeepArchemedea?: number;
+    EntratiLabConquestUnlocked?: number;
+    EntratiLabConquestActiveFrameVariants?: string[];
+    EchoesHexConquestUnlocked?: number;
+    EchoesHexConquestActiveFrameVariants?: string[];
+    EchoesHexConquestActiveStickers?: string[];
+}

src/controllers/api/evolveWeaponController.ts

@@ -1,32 +1,49 @@
-import { RequestHandler } from "express";
-import { getAccountIdForRequest } from "@/src/services/loginService";
-import { getInventory } from "@/src/services/inventoryService";
-import { getJSONfromString } from "@/src/helpers/stringHelpers";
-import { WeaponTypeInternal } from "@/src/services/itemDataService";
-import { EquipmentFeatures } from "@/src/types/inventoryTypes/commonInventoryTypes";
+import type { RequestHandler } from "express";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { addMiscItems, getInventory } from "../../services/inventoryService.ts";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import type { WeaponTypeInternal } from "../../services/itemDataService.ts";
+import { getRecipe } from "../../services/itemDataService.ts";
+import { EquipmentFeatures } from "../../types/equipmentTypes.ts";
 
-// eslint-disable-next-line @typescript-eslint/no-misused-promises
 export const evolveWeaponController: RequestHandler = async (req, res) => {
     const accountId = await getAccountIdForRequest(req);
     const inventory = await getInventory(accountId);
-    const payload = getJSONfromString(String(req.body)) as IEvolveWeaponRequest;
-    console.assert(payload.Action == "EWA_INSTALL");
+    const payload = getJSONfromString<IEvolveWeaponRequest>(String(req.body));
 
-    // TODO: We should remove the Genesis item & its resources, but currently we don't know these "recipes".
+    const recipe = getRecipe(payload.Recipe)!;
+    if (payload.Action == "EWA_INSTALL") {
+        addMiscItems(
+            inventory,
+            recipe.ingredients.map(x => ({ ItemType: x.ItemType, ItemCount: x.ItemCount * -1 }))
+        );
 
-    const item = inventory[payload.Category].find(item => item._id.toString() == (req.query.ItemId as string))!;
-    item.Features ??= 0;
-    item.Features |= EquipmentFeatures.INCARNON_GENESIS;
+        const item = inventory[payload.Category].id(req.query.ItemId as string)!;
+        item.Features ??= 0;
+        item.Features |= EquipmentFeatures.INCARNON_GENESIS;
 
-    item.SkillTree = "0";
+        item.SkillTree = "0";
 
-    inventory.EvolutionProgress ??= [];
-    if (!inventory.EvolutionProgress.find(entry => entry.ItemType == payload.EvoType)) {
-        inventory.EvolutionProgress.push({
-            Progress: 0,
-            Rank: 1,
-            ItemType: payload.EvoType
-        });
+        inventory.EvolutionProgress ??= [];
+        if (!inventory.EvolutionProgress.find(entry => entry.ItemType == payload.EvoType)) {
+            inventory.EvolutionProgress.push({
+                Progress: 0,
+                Rank: 1,
+                ItemType: payload.EvoType
+            });
+        }
+    } else if (payload.Action == "EWA_UNINSTALL") {
+        addMiscItems(inventory, [
+            {
+                ItemType: recipe.resultType,
+                ItemCount: 1
+            }
+        ]);
+
+        const item = inventory[payload.Category].id(req.query.ItemId as string)!;
+        item.Features! &= ~EquipmentFeatures.INCARNON_GENESIS;
+    } else {
+        throw new Error(`unexpected evolve weapon action: ${payload.Action}`);
     }
 
     await inventory.save();
@@ -34,7 +51,7 @@ export const evolveWeaponController: RequestHandler = async (req, res) => {
 };
 
 interface IEvolveWeaponRequest {
-    Action: "EWA_INSTALL";
+    Action: string;
     Category: WeaponTypeInternal;
     Recipe: string; // e.g. "/Lotus/Types/Items/MiscItems/IncarnonAdapters/UnlockerBlueprints/DespairIncarnonBlueprint"
     UninstallRecipe: "";

src/controllers/api/feedPrinceController.ts

@@ -0,0 +1,62 @@
+import type { RequestHandler } from "express";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { addMiscItem, getInventory } from "../../services/inventoryService.ts";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { logger } from "../../utils/logger.ts";
+import type { IInventoryChanges } from "../../types/purchaseTypes.ts";
+
+export const feedPrinceController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "MiscItems NokkoColony NodeIntrosCompleted");
+    const payload = getJSONfromString<IFeedPrinceRequest>(String(req.body));
+
+    switch (payload.Mode) {
+        case "r": {
+            inventory.NokkoColony ??= {
+                FeedLevel: 0,
+                JournalEntries: []
+            };
+            const InventoryChanges: IInventoryChanges = {};
+            inventory.NokkoColony.FeedLevel += payload.Amount;
+            if (
+                (!inventory.NodeIntrosCompleted.includes("CompletedVision1") && inventory.NokkoColony.FeedLevel > 20) ||
+                (!inventory.NodeIntrosCompleted.includes("CompletedVision2") && inventory.NokkoColony.FeedLevel > 60)
+            ) {
+                res.json({
+                    FeedSucceeded: false,
+                    FeedLevel: inventory.NokkoColony.FeedLevel - payload.Amount,
+                    InventoryChanges
+                } satisfies IFeedPrinceResponse);
+            } else {
+                addMiscItem(
+                    inventory,
+                    "/Lotus/Types/Items/MiscItems/MushroomFood",
+                    payload.Amount * -1,
+                    InventoryChanges
+                );
+                await inventory.save();
+                res.json({
+                    FeedSucceeded: true,
+                    FeedLevel: inventory.NokkoColony.FeedLevel,
+                    InventoryChanges
+                } satisfies IFeedPrinceResponse);
+            }
+            break;
+        }
+
+        default:
+            logger.debug(`data provided to ${req.path}: ${String(req.body)}`);
+            throw new Error(`unknown feedPrince mode: ${payload.Mode}`);
+    }
+};
+
+interface IFeedPrinceRequest {
+    Mode: string; // r
+    Amount: number;
+}
+
+interface IFeedPrinceResponse {
+    FeedSucceeded: boolean;
+    FeedLevel: number;
+    InventoryChanges: IInventoryChanges;
+}

src/controllers/api/findSessionsController.ts

@@ -1,31 +1,28 @@
-import { RequestHandler } from "express";
-import { getSession } from "@/src/managers/sessionManager";
-import { logger } from "@/src/utils/logger";
+import type { RequestHandler } from "express";
+import { getSession } from "../../managers/sessionManager.ts";
+import { logger } from "../../utils/logger.ts";
+import type { IFindSessionRequest } from "../../types/session.ts";
 
-//TODO: cleanup
-const findSessionsController: RequestHandler = (_req, res) => {
-    const reqBody = JSON.parse(String(_req.body));
-    logger.debug("FindSession Request ", { reqBody });
-    const req = JSON.parse(String(_req.body));
+export const findSessionsController: RequestHandler = (_req, res) => {
+    const req = JSON.parse(String(_req.body)) as IFindSessionRequest;
+    logger.debug("FindSession Request ", req);
     if (req.id != undefined) {
         logger.debug("Found ID");
-        const session = getSession(req.id as string);
+        const session = getSession(req.id);
 
-        if (session) res.json({ queryId: req.queryId, Sessions: session });
+        if (session.length) res.json({ queryId: req.queryId, Sessions: session });
         else res.json({});
     } else if (req.originalSessionId != undefined) {
         logger.debug("Found OriginalSessionID");
 
-        const session = getSession(req.originalSessionId as string);
-        if (session) res.json({ queryId: req.queryId, Sessions: session });
+        const session = getSession(req.originalSessionId);
+        if (session.length) res.json({ queryId: req.queryId, Sessions: session });
         else res.json({});
     } else {
         logger.debug("Found SessionRequest");
 
-        const session = getSession(String(_req.body));
-        if (session) res.json({ queryId: req.queryId, Sessions: session });
+        const session = getSession(req);
+        if (session.length) res.json({ queryId: req.queryId, Sessions: session });
         else res.json({});
     }
 };
-
-export { findSessionsController };

src/controllers/api/fishmongerController.ts

@@ -0,0 +1,46 @@
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { addMiscItems, addStanding, getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { IMiscItem } from "../../types/inventoryTypes/inventoryTypes.ts";
+import type { RequestHandler } from "express";
+import { ExportResources } from "warframe-public-export-plus";
+
+export const fishmongerController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId);
+    const body = getJSONfromString<IFishmongerRequest>(String(req.body));
+    const miscItemChanges: IMiscItem[] = [];
+    let syndicateTag: string | undefined;
+    let gainedStanding = 0;
+    for (const fish of body.Fish) {
+        const fishData = ExportResources[fish.ItemType];
+        if (req.query.dissect == "1") {
+            for (const part of fishData.dissectionParts!) {
+                const partItem = miscItemChanges.find(x => x.ItemType == part.ItemType);
+                if (partItem) {
+                    partItem.ItemCount += part.ItemCount * fish.ItemCount;
+                } else {
+                    miscItemChanges.push({ ItemType: part.ItemType, ItemCount: part.ItemCount * fish.ItemCount });
+                }
+            }
+        } else {
+            syndicateTag = fishData.syndicateTag!;
+            gainedStanding += fishData.standingBonus! * fish.ItemCount;
+        }
+        miscItemChanges.push({ ItemType: fish.ItemType, ItemCount: fish.ItemCount * -1 });
+    }
+    addMiscItems(inventory, miscItemChanges);
+    if (gainedStanding && syndicateTag) addStanding(inventory, syndicateTag, gainedStanding);
+    await inventory.save();
+    res.json({
+        InventoryChanges: {
+            MiscItems: miscItemChanges
+        },
+        SyndicateTag: syndicateTag,
+        StandingChange: gainedStanding
+    });
+};
+
+interface IFishmongerRequest {
+    Fish: IMiscItem[];
+}

src/controllers/api/focusController.ts

@@ -1,28 +1,117 @@
-import { RequestHandler } from "express";
-import { getAccountIdForRequest } from "@/src/services/loginService";
-import { getInventory, addMiscItems, addEquipment } from "@/src/services/inventoryService";
-import { IMiscItem, TFocusPolarity } from "@/src/types/inventoryTypes/inventoryTypes";
-import { logger } from "@/src/utils/logger";
+import type { RequestHandler } from "express";
+import { getAccountForRequest } from "../../services/loginService.ts";
+import { getInventory, addMiscItems, addEquipment, occupySlot } from "../../services/inventoryService.ts";
+import type { IMiscItem, TFocusPolarity, TEquipmentKey } from "../../types/inventoryTypes/inventoryTypes.ts";
+import { InventorySlot } from "../../types/inventoryTypes/inventoryTypes.ts";
+import { logger } from "../../utils/logger.ts";
 import { ExportFocusUpgrades } from "warframe-public-export-plus";
+import { Inventory } from "../../models/inventoryModels/inventoryModel.ts";
+import { version_compare } from "../../helpers/inventoryHelpers.ts";
 
-// eslint-disable-next-line @typescript-eslint/no-misused-promises
 export const focusController: RequestHandler = async (req, res) => {
-    const accountId = await getAccountIdForRequest(req);
-    switch (req.query.op) {
+    const account = await getAccountForRequest(req);
+
+    let op = req.query.op as string;
+    const focus2 = account.BuildLabel && version_compare(account.BuildLabel, "2022.04.29.12.53") < 0;
+    if (focus2) {
+        // Focus 2.0
+        switch (req.query.op) {
+            case Focus2Operation.InstallLens:
+                op = "InstallLens";
+                break;
+            case Focus2Operation.UnlockWay:
+                op = "UnlockWay";
+                break;
+            case Focus2Operation.UnlockUpgrade:
+                op = "UnlockUpgrade";
+                break;
+            case Focus2Operation.IncreasePool:
+                op = "IncreasePool";
+                break;
+            case Focus2Operation.LevelUpUpgrade:
+                op = "LevelUpUpgrade";
+                break;
+            case Focus2Operation.ActivateWay:
+                op = "ActivateWay";
+                break;
+            case Focus2Operation.UpdateUpgrade:
+                op = "UpdateUpgrade";
+                break;
+            case Focus2Operation.SentTrainingAmplifier:
+                op = "SentTrainingAmplifier";
+                break;
+            case Focus2Operation.UnbindUpgrade:
+                op = "UnbindUpgrade";
+                break;
+            case Focus2Operation.ConvertShard:
+                op = "ConvertShard";
+                break;
+        }
+    } else {
+        // Focus 3.0
+        switch (req.query.op) {
+            case Focus3Operation.InstallLens:
+                op = "InstallLens";
+                break;
+            case Focus3Operation.UnlockWay:
+                op = "UnlockWay";
+                break;
+            case Focus3Operation.UnlockUpgrade:
+                op = "UnlockUpgrade";
+                break;
+            case Focus3Operation.LevelUpUpgrade:
+                op = "LevelUpUpgrade";
+                break;
+            case Focus3Operation.ActivateWay:
+                op = "ActivateWay";
+                break;
+            case Focus3Operation.SentTrainingAmplifier:
+                op = "SentTrainingAmplifier";
+                break;
+            case Focus3Operation.UnbindUpgrade:
+                op = "UnbindUpgrade";
+                break;
+            case Focus3Operation.ConvertShard:
+                op = "ConvertShard";
+                break;
+        }
+    }
+
+    switch (op) {
         default:
-            logger.error("Unhandled focus op type: " + req.query.op);
-            logger.debug(req.body.toString());
+            logger.error("Unhandled focus op type: " + String(req.query.op));
+            logger.debug(String(req.body));
             res.end();
             break;
-        case FocusOperation.UnlockWay: {
+        case "InstallLens": {
+            const request = JSON.parse(String(req.body)) as ILensInstallRequest;
+            const inventory = await getInventory(account._id.toString());
+            const item = inventory[request.Category].id(request.WeaponId);
+            if (item) {
+                item.FocusLens = request.LensType;
+                addMiscItems(inventory, [
+                    {
+                        ItemType: request.LensType,
+                        ItemCount: -1
+                    } satisfies IMiscItem
+                ]);
+            }
+            await inventory.save();
+            res.json({
+                weaponId: request.WeaponId,
+                lensType: request.LensType
+            });
+            break;
+        }
+        case "UnlockWay": {
             const focusType = (JSON.parse(String(req.body)) as IWayRequest).FocusType;
             const focusPolarity = focusTypeToPolarity(focusType);
-            const inventory = await getInventory(accountId);
+            const inventory = await getInventory(account._id.toString(), "FocusAbility FocusUpgrades FocusXP");
             const cost = inventory.FocusAbility ? 50_000 : 0;
             inventory.FocusAbility ??= focusType;
             inventory.FocusUpgrades.push({ ItemType: focusType });
-            if (inventory.FocusXP) {
-                inventory.FocusXP[focusPolarity] -= cost;
+            if (cost) {
+                inventory.FocusXP![focusPolarity]! -= cost;
             }
             await inventory.save();
             res.json({
@@ -31,24 +120,57 @@ export const focusController: RequestHandler = async (req, res) => {
             });
             break;
         }
-        case FocusOperation.ActivateWay: {
-            const focusType = (JSON.parse(String(req.body)) as IWayRequest).FocusType;
-            const inventory = await getInventory(accountId);
-            inventory.FocusAbility = focusType;
+        case "IncreasePool": {
+            const request = JSON.parse(String(req.body)) as IIncreasePoolRequest;
+            const focusPolarity = focusTypeToPolarity(request.FocusType);
+            const inventory = await getInventory(account._id.toString(), "FocusXP FocusCapacity");
+            let cost = 0;
+            for (let capacity = request.CurrentTotalCapacity; capacity != request.NewTotalCapacity; ++capacity) {
+                cost += increasePoolCost[capacity - 5];
+            }
+            inventory.FocusXP![focusPolarity]! -= cost;
+            inventory.FocusCapacity = request.NewTotalCapacity;
             await inventory.save();
-            res.end();
+            res.json({
+                TotalCapacity: request.NewTotalCapacity,
+                FocusPointCosts: { [focusPolarity]: cost }
+            });
             break;
         }
-        case FocusOperation.UnlockUpgrade: {
+        case "ActivateWay": {
+            const focusType = (JSON.parse(String(req.body)) as IWayRequest).FocusType;
+
+            await Inventory.updateOne(
+                {
+                    accountOwnerId: account._id.toString()
+                },
+                {
+                    FocusAbility: focusType
+                }
+            );
+
+            res.json({
+                FocusUpgrade: { ItemType: focusType }
+            });
+            break;
+        }
+        case "UnlockUpgrade": {
             const request = JSON.parse(String(req.body)) as IUnlockUpgradeRequest;
             const focusPolarity = focusTypeToPolarity(request.FocusTypes[0]);
-            const inventory = await getInventory(accountId);
+            const inventory = await getInventory(account._id.toString());
             let cost = 0;
             for (const focusType of request.FocusTypes) {
-                cost += ExportFocusUpgrades[focusType].baseFocusPointCost;
+                if (focusType in ExportFocusUpgrades) {
+                    cost += ExportFocusUpgrades[focusType].baseFocusPointCost;
+                } else if (focusType == "/Lotus/Upgrades/Focus/Power/Residual/ChannelEfficiencyFocusUpgrade") {
+                    // Zenurik's Inner Might (Focus 2.0)
+                    cost += 50_000;
+                } else {
+                    logger.warn(`unknown focus upgrade ${focusType}, will unlock it for free`);
+                }
                 inventory.FocusUpgrades.push({ ItemType: focusType, Level: 0 });
             }
-            inventory.FocusXP[focusPolarity] -= cost;
+            inventory.FocusXP![focusPolarity]! -= cost;
             await inventory.save();
             res.json({
                 FocusTypes: request.FocusTypes,
@@ -56,17 +178,22 @@ export const focusController: RequestHandler = async (req, res) => {
             });
             break;
         }
-        case FocusOperation.LevelUpUpgrade: {
+        case "LevelUpUpgrade":
+        case "UpdateUpgrade": {
             const request = JSON.parse(String(req.body)) as ILevelUpUpgradeRequest;
             const focusPolarity = focusTypeToPolarity(request.FocusInfos[0].ItemType);
-            const inventory = await getInventory(accountId);
+            const inventory = await getInventory(account._id.toString());
             let cost = 0;
             for (const focusUpgrade of request.FocusInfos) {
                 cost += focusUpgrade.FocusXpCost;
                 const focusUpgradeDb = inventory.FocusUpgrades.find(entry => entry.ItemType == focusUpgrade.ItemType)!;
-                focusUpgradeDb.Level = focusUpgrade.Level;
+                if (op == "UpdateUpgrade") {
+                    focusUpgradeDb.IsActive = focusUpgrade.IsActive;
+                } else {
+                    focusUpgradeDb.Level = focusUpgrade.Level;
+                }
             }
-            inventory.FocusXP[focusPolarity] -= cost;
+            inventory.FocusXP![focusPolarity]! -= cost;
             await inventory.save();
             res.json({
                 FocusInfos: request.FocusInfos,
@@ -74,22 +201,26 @@ export const focusController: RequestHandler = async (req, res) => {
             });
             break;
         }
-        case FocusOperation.SentTrainingAmplifier: {
+        case "SentTrainingAmplifier": {
             const request = JSON.parse(String(req.body)) as ISentTrainingAmplifierRequest;
-            const parts: string[] = [
-                "/Lotus/Weapons/Sentients/OperatorAmplifiers/SentTrainingAmplifier/SentAmpTrainingGrip",
-                "/Lotus/Weapons/Sentients/OperatorAmplifiers/SentTrainingAmplifier/SentAmpTrainingChassis",
-                "/Lotus/Weapons/Sentients/OperatorAmplifiers/SentTrainingAmplifier/SentAmpTrainingBarrel"
-            ];
-            const result = await addEquipment("OperatorAmps", request.StartingWeaponType, accountId, parts);
-            res.json(result);
+            const inventory = await getInventory(account._id.toString());
+            const inventoryChanges = addEquipment(inventory, "OperatorAmps", request.StartingWeaponType, {
+                ModularParts: [
+                    "/Lotus/Weapons/Sentients/OperatorAmplifiers/SentTrainingAmplifier/SentAmpTrainingGrip",
+                    "/Lotus/Weapons/Sentients/OperatorAmplifiers/SentTrainingAmplifier/SentAmpTrainingChassis",
+                    "/Lotus/Weapons/Sentients/OperatorAmplifiers/SentTrainingAmplifier/SentAmpTrainingBarrel"
+                ]
+            });
+            occupySlot(inventory, InventorySlot.AMPS, false);
+            await inventory.save();
+            res.json(inventoryChanges.OperatorAmps![0]);
             break;
         }
-        case FocusOperation.UnbindUpgrade: {
+        case "UnbindUpgrade": {
             const request = JSON.parse(String(req.body)) as IUnbindUpgradeRequest;
             const focusPolarity = focusTypeToPolarity(request.FocusTypes[0]);
-            const inventory = await getInventory(accountId);
-            inventory.FocusXP[focusPolarity] -= 750_000 * request.FocusTypes.length;
+            const inventory = await getInventory(account._id.toString());
+            inventory.FocusXP![focusPolarity]! -= 750_000 * request.FocusTypes.length;
             addMiscItems(inventory, [
                 {
                     ItemType: "/Lotus/Types/Gameplay/Eidolon/Resources/SentientShards/SentientShardBrilliantItem",
@@ -115,7 +246,7 @@ export const focusController: RequestHandler = async (req, res) => {
             });
             break;
         }
-        case FocusOperation.ConvertShard: {
+        case "ConvertShard": {
             const request = JSON.parse(String(req.body)) as IConvertShardRequest;
             // Tally XP
             let xp = 0;
@@ -133,9 +264,11 @@ export const focusController: RequestHandler = async (req, res) => {
             for (const shard of request.Shards) {
                 shard.ItemCount *= -1;
             }
-            const inventory = await getInventory(accountId);
-            inventory.FocusXP ??= { AP_POWER: 0, AP_TACTIC: 0, AP_DEFENSE: 0, AP_ATTACK: 0, AP_WARD: 0 };
-            inventory.FocusXP[request.Polarity] += xp;
+            const inventory = await getInventory(account._id.toString());
+            const polarity = request.Polarity;
+            inventory.FocusXP ??= {};
+            inventory.FocusXP[polarity] ??= 0;
+            inventory.FocusXP[polarity] += xp;
             addMiscItems(inventory, request.Shards);
             await inventory.save();
             break;
@@ -143,7 +276,9 @@ export const focusController: RequestHandler = async (req, res) => {
     }
 };
 
-enum FocusOperation {
+// Focus 3.0
+enum Focus3Operation {
+    InstallLens = "1",
     UnlockWay = "2",
     UnlockUpgrade = "3",
     LevelUpUpgrade = "4",
@@ -153,6 +288,20 @@ enum FocusOperation {
     ConvertShard = "9"
 }
 
+// Focus 2.0
+enum Focus2Operation {
+    InstallLens = "1",
+    UnlockWay = "2",
+    UnlockUpgrade = "3",
+    IncreasePool = "4",
+    LevelUpUpgrade = "5",
+    ActivateWay = "6",
+    UpdateUpgrade = "7", // used to change the IsActive state, same format as ILevelUpUpgradeRequest
+    SentTrainingAmplifier = "9",
+    UnbindUpgrade = "10",
+    ConvertShard = "11"
+}
+
 // For UnlockWay & ActivateWay
 interface IWayRequest {
     FocusType: string;
@@ -162,6 +311,13 @@ interface IUnlockUpgradeRequest {
     FocusTypes: string[];
 }
 
+// Focus 2.0
+interface IIncreasePoolRequest {
+    FocusType: string;
+    CurrentTotalCapacity: number;
+    NewTotalCapacity: number;
+}
+
 interface ILevelUpUpgradeRequest {
     FocusInfos: {
         ItemType: string;
@@ -169,6 +325,7 @@ interface ILevelUpUpgradeRequest {
         IsUniversal: boolean;
         Level: number;
         IsActiveAbility: boolean;
+        IsActive?: number; // Focus 2.0
     }[];
 }
 
@@ -186,9 +343,15 @@ interface ISentTrainingAmplifierRequest {
     StartingWeaponType: string;
 }
 
+interface ILensInstallRequest {
+    LensType: string;
+    Category: TEquipmentKey;
+    WeaponId: string;
+}
+
 // Works for ways & upgrades
 const focusTypeToPolarity = (type: string): TFocusPolarity => {
-    return ("AP_" + type.substr(1).split("/")[3].toUpperCase()) as TFocusPolarity;
+    return ("AP_" + type.substring(1).split("/")[3].toUpperCase()) as TFocusPolarity;
 };
 
 const shardValues = {
@@ -197,3 +360,19 @@ const shardValues = {
     "/Lotus/Types/Gameplay/Eidolon/Resources/SentientShards/SentientShardBrilliantItem": 25_000,
     "/Lotus/Types/Gameplay/Eidolon/Resources/SentientShards/SentientShardBrilliantTierTwoItem": 40_000
 };
+
+// Starting at a capacity of 5 (Source: https://wiki.warframe.com/w/Focus_2.0)
+const increasePoolCost = [
+    2576, 3099, 3638, 4190, 4755, 5331, 5918, 6514, 7120, 7734, 8357, 8988, 9626, 10271, 10923, 11582, 12247, 12918,
+    13595, 14277, 14965, 15659, 16357, 17061, 17769, 18482, 19200, 19922, 20649, 21380, 22115, 22854, 23597, 24344,
+    25095, 25850, 26609, 27371, 28136, 28905, 29678, 30454, 31233, 32015, 32801, 33590, 34382, 35176, 35974, 36775,
+    37579, 38386, 39195, 40008, 40823, 41641, 42461, 43284, 44110, 44938, 45769, 46603, 47439, 48277, 49118, 49961,
+    50807, 51655, 52505, 53357, 54212, 55069, 55929, 56790, 57654, 58520, 59388, 60258, 61130, 62005, 62881, 63759,
+    64640, 65522, 66407, 67293, 68182, 69072, 69964, 70858, 71754, 72652, 73552, 74453, 75357, 76262, 77169, 78078,
+    78988, 79900, 80814, 81730, 82648, 83567, 84488, 85410, 86334, 87260, 88188, 89117, 90047, 90980, 91914, 92849,
+    93786, 94725, 95665, 96607, 97550, 98495, 99441, 100389, 101338, 102289, 103241, 104195, 105150, 106107, 107065,
+    108024, 108985, 109948, 110911, 111877, 112843, 113811, 114780, 115751, 116723, 117696, 118671, 119647, 120624,
+    121603, 122583, 123564, 124547, 125531, 126516, 127503, 128490, 129479, 130470, 131461, 132454, 133448, 134443,
+    135440, 136438, 137437, 138437, 139438, 140441, 141444, 142449, 143455, 144463, 145471, 146481, 147492, 148503,
+    149517
+];

src/controllers/api/forceRemoveItemController.ts

@@ -0,0 +1,27 @@
+import type { RequestHandler } from "express";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import type { IInventoryChanges } from "../../types/purchaseTypes.ts";
+
+export const forceRemoveItemController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "MiscItems");
+    const body = getJSONfromString<IForceRemoveItemRequest>(String(req.body));
+    const inventoryChanges: IInventoryChanges = {};
+    for (const item of body.items) {
+        const index = inventory.MiscItems.findIndex(x => x.ItemType == item);
+        if (index != -1) {
+            inventoryChanges.MiscItems ??= [];
+            inventoryChanges.MiscItems.push({ ItemType: item, ItemCount: inventory.MiscItems[index].ItemCount * -1 });
+
+            inventory.MiscItems.splice(index, 1);
+        }
+    }
+    await inventory.save();
+    res.json({ InventoryChanges: inventoryChanges });
+};
+
+interface IForceRemoveItemRequest {
+    items: string[];
+}

src/controllers/api/fusionTreasuresController.ts

@@ -0,0 +1,44 @@
+import type { RequestHandler } from "express";
+import { ExportResources } from "warframe-public-export-plus";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { addFusionTreasures, addMiscItems, getInventory } from "../../services/inventoryService.ts";
+import type { IMiscItem } from "../../types/inventoryTypes/inventoryTypes.ts";
+import { parseFusionTreasure } from "../../helpers/inventoryHelpers.ts";
+
+interface IFusionTreasureRequest {
+    oldTreasureName: string;
+    newTreasureName: string;
+}
+
+export const fusionTreasuresController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId);
+    const request = JSON.parse(String(req.body)) as IFusionTreasureRequest;
+
+    // Swap treasures
+    const oldTreasure = parseFusionTreasure(request.oldTreasureName, -1);
+    const newTreasure = parseFusionTreasure(request.newTreasureName, 1);
+    const fusionTreasureChanges = [oldTreasure, newTreasure];
+    addFusionTreasures(inventory, fusionTreasureChanges);
+
+    // Remove consumed stars
+    const miscItemChanges: IMiscItem[] = [];
+    const filledSockets = newTreasure.Sockets & ~oldTreasure.Sockets;
+    for (let i = 0; filledSockets >> i; ++i) {
+        if ((filledSockets >> i) & 1) {
+            //console.log("Socket", i, "has been filled with", ExportResources[oldTreasure.ItemType].sockets![i]);
+            miscItemChanges.push({
+                ItemType: ExportResources[oldTreasure.ItemType].sockets![i],
+                ItemCount: -1
+            });
+        }
+    }
+    addMiscItems(inventory, miscItemChanges);
+
+    await inventory.save();
+    // The response itself is the inventory changes for this endpoint.
+    res.json({
+        MiscItems: miscItemChanges,
+        FusionTreasures: fusionTreasureChanges
+    });
+};

src/controllers/api/gardeningController.ts

@@ -0,0 +1,83 @@
+import { toMongoDate } from "../../helpers/inventoryHelpers.ts";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import { addMiscItem, getInventory } from "../../services/inventoryService.ts";
+import { toStoreItem } from "../../services/itemDataService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { createGarden, getPersonalRooms } from "../../services/personalRoomsService.ts";
+import type { IMongoDate } from "../../types/commonTypes.ts";
+import type { IMissionReward } from "../../types/missionTypes.ts";
+import type { IGardeningClient, IPersonalRoomsClient } from "../../types/personalRoomsTypes.ts";
+import type { IInventoryChanges } from "../../types/purchaseTypes.ts";
+import type { RequestHandler } from "express";
+import { dict_en, ExportResources } from "warframe-public-export-plus";
+
+export const gardeningController: RequestHandler = async (req, res) => {
+    const data = getJSONfromString<IGardeningRequest>(String(req.body));
+    if (data.Mode != "HarvestAll") {
+        throw new Error(`unexpected gardening mode: ${data.Mode}`);
+    }
+
+    const accountId = await getAccountIdForRequest(req);
+    const [inventory, personalRooms] = await Promise.all([
+        getInventory(accountId, "MiscItems"),
+        getPersonalRooms(accountId, "Apartment")
+    ]);
+
+    // Harvest plants
+    const inventoryChanges: IInventoryChanges = {};
+    const rewards: Record<string, IMissionReward[][]> = {};
+    for (const planter of personalRooms.Apartment.Gardening.Planters) {
+        rewards[planter.Name] = [];
+        for (const plant of planter.Plants) {
+            const itemType =
+                "/Lotus/Types/Gameplay/Duviri/Resource/DuviriPlantItem" +
+                plant.PlantType.substring(plant.PlantType.length - 1);
+            const itemCount = Math.random() < 0.775 ? 2 : 4;
+
+            addMiscItem(inventory, itemType, itemCount, inventoryChanges);
+
+            rewards[planter.Name].push([
+                {
+                    StoreItem: toStoreItem(itemType),
+                    TypeName: itemType,
+                    ItemCount: itemCount,
+                    DailyCooldown: false,
+                    Rarity: itemCount == 2 ? 0.7743589743589744 : 0.22564102564102564,
+                    TweetText: `${itemCount}x ${dict_en[ExportResources[itemType].name]} (Resource)`,
+                    ProductCategory: "MiscItems"
+                }
+            ]);
+        }
+    }
+
+    // Refresh garden
+    personalRooms.Apartment.Gardening = createGarden();
+
+    await Promise.all([inventory.save(), personalRooms.save()]);
+
+    const planter = personalRooms.Apartment.Gardening.Planters[personalRooms.Apartment.Gardening.Planters.length - 1];
+    const plant = planter.Plants[planter.Plants.length - 1];
+    res.json({
+        GardenTagName: planter.Name,
+        PlantType: plant.PlantType,
+        PlotIndex: plant.PlotIndex,
+        EndTime: toMongoDate(plant.EndTime),
+        InventoryChanges: inventoryChanges,
+        Gardening: personalRooms.toJSON<IPersonalRoomsClient>().Apartment.Gardening,
+        Rewards: rewards
+    } satisfies IGardeningResponse);
+};
+
+interface IGardeningRequest {
+    Mode: string;
+}
+
+interface IGardeningResponse {
+    GardenTagName: string;
+    PlantType: string;
+    PlotIndex: number;
+    EndTime: IMongoDate;
+    InventoryChanges: IInventoryChanges;
+    Gardening: IGardeningClient;
+    Rewards: Record<string, IMissionReward[][]>;
+}

src/controllers/api/genericUpdateController.ts

@@ -1,16 +1,15 @@
-import { getAccountIdForRequest } from "@/src/services/loginService";
-import { updateGeneric } from "@/src/services/inventoryService";
-import { RequestHandler } from "express";
-import { getJSONfromString } from "@/src/helpers/stringHelpers";
-import { IGenericUpdate } from "@/src/types/genericUpdate";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { updateGeneric } from "../../services/inventoryService.ts";
+import type { RequestHandler } from "express";
+import { getJSONfromString } from "../../helpers/stringHelpers.ts";
+import type { IGenericUpdate } from "../../types/genericUpdate.ts";
 
 // This endpoint used to be /api/genericUpdate.php, but sometime around the Jade Shadows update, it was changed to /api/updateNodeIntros.php.
 // SpaceNinjaServer supports both endpoints right now.
 
-// eslint-disable-next-line @typescript-eslint/no-misused-promises
 const genericUpdateController: RequestHandler = async (request, response) => {
     const accountId = await getAccountIdForRequest(request);
-    const update = getJSONfromString(String(request.body)) as IGenericUpdate;
+    const update = getJSONfromString<IGenericUpdate>(String(request.body));
     response.json(await updateGeneric(update, accountId));
 };
 

src/controllers/api/getAllianceController.ts

@@ -1,7 +1,26 @@
-import { RequestHandler } from "express";
+import { Alliance, Guild } from "../../models/guildModel.ts";
+import { getAllianceClient } from "../../services/guildService.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { RequestHandler } from "express";
 
-const getAllianceController: RequestHandler = (_req, res) => {
-    res.sendStatus(200);
+export const getAllianceController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "GuildId");
+    if (inventory.GuildId) {
+        const guild = (await Guild.findById(inventory.GuildId, "Name Tier AllianceId"))!;
+        if (guild.AllianceId) {
+            const alliance = (await Alliance.findById(guild.AllianceId))!;
+            res.json(await getAllianceClient(alliance, guild));
+            return;
+        }
+    }
+    res.end();
 };
 
-export { getAllianceController };
+// POST request since U27
+/*interface IGetAllianceRequest {
+    memberCount: number;
+    clanLeaderName: string;
+    clanLeaderId: string;
+}*/

src/controllers/api/getCreditsController.ts

@@ -1,29 +0,0 @@
-import { RequestHandler } from "express";
-import { config } from "@/src/services/configService";
-import { getAccountIdForRequest } from "@/src/services/loginService";
-import { getInventory } from "@/src/services/inventoryService";
-
-// eslint-disable-next-line @typescript-eslint/no-misused-promises
-export const getCreditsController: RequestHandler = async (req, res) => {
-    let accountId;
-    try {
-        accountId = await getAccountIdForRequest(req);
-    } catch (e) {
-        res.status(400).send("Log-in expired");
-        return;
-    }
-
-    if (config.infiniteResources) {
-        res.json({
-            RegularCredits: 999999999,
-            PremiumCredits: 999999999
-        });
-        return;
-    }
-
-    const inventory = await getInventory(accountId);
-    res.json({
-        RegularCredits: inventory.RegularCredits,
-        PremiumCredits: inventory.PremiumCredits
-    });
-};

src/controllers/api/getDailyDealStockLevelsController.ts

@@ -1,8 +1,10 @@
-import { RequestHandler } from "express";
+import { DailyDeal } from "../../models/worldStateModel.ts";
+import type { RequestHandler } from "express";
 
-export const getDailyDealStockLevelsController: RequestHandler = (req, res) => {
+export const getDailyDealStockLevelsController: RequestHandler = async (req, res) => {
+    const dailyDeal = (await DailyDeal.findOne({ StoreItem: req.query.productName }, "AmountSold"))!;
     res.json({
         StoreItem: req.query.productName,
-        AmountSold: 0
+        AmountSold: dailyDeal.AmountSold
     });
 };

src/controllers/api/getFriendsController.ts

@@ -1,14 +1,55 @@
-import { Request, Response } from "express";
+import { toOid2 } from "../../helpers/inventoryHelpers.ts";
+import { Friendship } from "../../models/friendModel.ts";
+import { addAccountDataToFriendInfo, addInventoryDataToFriendInfo } from "../../services/friendService.ts";
+import { getAccountForRequest } from "../../services/loginService.ts";
+import type { IFriendInfo } from "../../types/friendTypes.ts";
+import type { Request, RequestHandler, Response } from "express";
 
-const getFriendsController = (_request: Request, response: Response) => {
-    response.writeHead(200, {
-        //Connection: "keep-alive",
-        //"Content-Encoding": "gzip",
-        "Content-Type": "text/html",
-        // charset: "UTF - 8",
-        "Content-Length": "3"
-    });
-    response.end(Buffer.from([0x7b, 0x7d, 0x0a]));
+// POST with {} instead of GET as of 38.5.0
+export const getFriendsController: RequestHandler = async (req: Request, res: Response) => {
+    const account = await getAccountForRequest(req);
+    const accountId = account._id.toString();
+    const response: IGetFriendsResponse = {
+        Current: [],
+        IncomingFriendRequests: [],
+        OutgoingFriendRequests: []
+    };
+    const [internalFriendships, externalFriendships] = await Promise.all([
+        Friendship.find({ owner: accountId }),
+        Friendship.find({ friend: accountId }, "owner Note")
+    ]);
+    for (const externalFriendship of externalFriendships) {
+        if (!internalFriendships.find(x => x.friend.equals(externalFriendship.owner))) {
+            response.IncomingFriendRequests.push({
+                _id: toOid2(externalFriendship.owner, account.BuildLabel),
+                Note: externalFriendship.Note
+            });
+        }
+    }
+    for (const internalFriendship of internalFriendships) {
+        const friendInfo: IFriendInfo = {
+            _id: toOid2(internalFriendship.friend, account.BuildLabel)
+        };
+        if (externalFriendships.find(x => x.owner.equals(internalFriendship.friend))) {
+            response.Current.push(friendInfo);
+        } else {
+            response.OutgoingFriendRequests.push(friendInfo);
+        }
+    }
+    const promises: Promise<void>[] = [];
+    for (const arr of Object.values(response)) {
+        for (const friendInfo of arr) {
+            promises.push(addAccountDataToFriendInfo(friendInfo));
+            promises.push(addInventoryDataToFriendInfo(friendInfo));
+        }
+    }
+    await Promise.all(promises);
+    res.json(response);
 };
 
-export { getFriendsController };
+// interface IGetFriendsResponse {
+//     Current: IFriendInfo[];
+//     IncomingFriendRequests: IFriendInfo[];
+//     OutgoingFriendRequests: IFriendInfo[];
+// }
+type IGetFriendsResponse = Record<"Current" | "IncomingFriendRequests" | "OutgoingFriendRequests", IFriendInfo[]>;

src/controllers/api/getGuildContributionsController.ts

@@ -0,0 +1,19 @@
+import { GuildMember } from "../../models/guildModel.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { IGuildMemberClient } from "../../types/guildTypes.ts";
+import type { RequestHandler } from "express";
+
+export const getGuildContributionsController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const guildId = (await getInventory(accountId, "GuildId")).GuildId;
+    const guildMember = (await GuildMember.findOne({ guildId, accountId: req.query.buddyId }))!;
+    res.json({
+        _id: { $oid: req.query.buddyId as string },
+        RegularCreditsContributed: guildMember.RegularCreditsContributed,
+        PremiumCreditsContributed: guildMember.PremiumCreditsContributed,
+        MiscItemsContributed: guildMember.MiscItemsContributed,
+        ConsumablesContributed: [], // ???
+        ShipDecorationsContributed: guildMember.ShipDecorationsContributed
+    } satisfies Partial<IGuildMemberClient>);
+};

src/controllers/api/getGuildController.ts

@@ -1,7 +1,32 @@
-import { RequestHandler } from "express";
+import type { RequestHandler } from "express";
+import { Guild } from "../../models/guildModel.ts";
+import { getAccountForRequest } from "../../services/loginService.ts";
+import { logger } from "../../utils/logger.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { createUniqueClanName, getGuildClient } from "../../services/guildService.ts";
 
-const getGuildController: RequestHandler = (_, res) => {
-    res.json({});
+export const getGuildController: RequestHandler = async (req, res) => {
+    const account = await getAccountForRequest(req);
+    const inventory = await getInventory(account._id.toString(), "GuildId");
+    if (inventory.GuildId) {
+        const guild = await Guild.findById(inventory.GuildId);
+        if (guild) {
+            // Handle guilds created before we added discriminators
+            if (guild.Name.indexOf("#") == -1) {
+                guild.Name = await createUniqueClanName(guild.Name);
+                await guild.save();
+            }
+
+            if (guild.CeremonyResetDate && Date.now() >= guild.CeremonyResetDate.getTime()) {
+                logger.debug(`ascension ceremony is over`);
+                guild.CeremonyEndo = undefined;
+                guild.CeremonyContributors = undefined;
+                guild.CeremonyResetDate = undefined;
+                await guild.save();
+            }
+            res.json(await getGuildClient(guild, account));
+            return;
+        }
+    }
+    res.end();
 };
-
-export { getGuildController };

src/controllers/api/getGuildDojoController.ts

@@ -1,60 +1,35 @@
-import { RequestHandler } from "express";
+import type { RequestHandler } from "express";
 import { Types } from "mongoose";
-import { Guild } from "@/src/models/guildModel";
-import { IDojoClient, IDojoComponentClient } from "@/src/types/guildTypes";
-import { toOid, toMongoDate } from "@/src/helpers/inventoryHelpers";
+import { Guild } from "../../models/guildModel.ts";
+import { getDojoClient } from "../../services/guildService.ts";
+import { Account } from "../../models/loginModel.ts";
 
-// eslint-disable-next-line @typescript-eslint/no-misused-promises
 export const getGuildDojoController: RequestHandler = async (req, res) => {
     const guildId = req.query.guildId as string;
 
-    const guild = await Guild.findOne({ _id: guildId });
+    const guild = await Guild.findById(guildId);
     if (!guild) {
         res.status(404).end();
         return;
     }
 
     // Populate dojo info if not present
-    if (!guild.DojoComponents || guild.DojoComponents.length == 0) {
-        guild.DojoComponents = [
-            {
-                _id: new Types.ObjectId(),
-                pf: "/Lotus/Levels/ClanDojo/DojoHall.level",
-                ppf: "",
-                CompletionTime: new Date(Date.now())
-            }
-        ];
+    if (guild.DojoComponents.length == 0) {
+        guild.DojoComponents.push({
+            _id: new Types.ObjectId(),
+            pf: "/Lotus/Levels/ClanDojo/DojoHall.level",
+            ppf: "",
+            CompletionTime: new Date(Date.now() - 1000),
+            DecoCapacity: 600
+        });
         await guild.save();
     }
 
-    const dojo: IDojoClient = {
-        _id: { $id: guildId },
-        Name: guild.Name,
-        Tier: 1,
-        FixedContributions: true,
-        DojoRevision: 1,
-        RevisionTime: Math.round(Date.now() / 1000),
-        Energy: 5,
-        Capacity: 100,
-        DojoRequestStatus: 0,
-        DojoComponents: []
-    };
-    guild.DojoComponents.forEach(dojoComponent => {
-        const clientComponent: IDojoComponentClient = {
-            id: toOid(dojoComponent._id),
-            pf: dojoComponent.pf,
-            ppf: dojoComponent.ppf,
-            DecoCapacity: 600
-        };
-        if (dojoComponent.pi) {
-            clientComponent.pi = toOid(dojoComponent.pi);
-            clientComponent.op = dojoComponent.op!;
-            clientComponent.pp = dojoComponent.pp!;
-        }
-        if (dojoComponent.CompletionTime) {
-            clientComponent.CompletionTime = toMongoDate(dojoComponent.CompletionTime);
-        }
-        dojo.DojoComponents.push(clientComponent);
-    });
-    res.json(dojo);
+    const payload: IGetGuildDojoRequest = req.body ? (JSON.parse(String(req.body)) as IGetGuildDojoRequest) : {};
+    const account = await Account.findById(req.query.accountId as string);
+    res.json(await getDojoClient(guild, 0, payload.ComponentId, account?.BuildLabel));
 };
+
+interface IGetGuildDojoRequest {
+    ComponentId?: string;
+}

src/controllers/api/getGuildEventScoreController.ts

@@ -0,0 +1,26 @@
+import type { RequestHandler } from "express";
+import { getAccountForRequest } from "../../services/loginService.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { Guild } from "../../models/guildModel.ts";
+
+export const getGuildEventScoreController: RequestHandler = async (req, res) => {
+    const account = await getAccountForRequest(req);
+    const inventory = await getInventory(account._id.toString(), "GuildId");
+    const guild = await Guild.findById(inventory.GuildId);
+    const goalId = req.query.goalId as string;
+    if (guild && guild.GoalProgress && goalId) {
+        const goal = guild.GoalProgress.find(x => x.goalId.toString() == goalId);
+        if (goal) {
+            res.json({
+                Tier: guild.Tier,
+                GoalProgress: {
+                    Count: goal.Count,
+                    Tag: goal.Tag,
+                    _id: { $oid: goal.goalId }
+                }
+            });
+            return;
+        }
+    }
+    res.json({});
+};

src/controllers/api/getGuildLogController.ts

@@ -1,11 +1,60 @@
-import { RequestHandler } from "express";
+import { toMongoDate } from "../../helpers/inventoryHelpers.ts";
+import { Guild } from "../../models/guildModel.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { IMongoDate } from "../../types/commonTypes.ts";
+import type { RequestHandler } from "express";
 
-export const getGuildLogController: RequestHandler = (_req, res) => {
-    res.json({
-        RoomChanges: [],
-        TechChanges: [],
-        RosterActivity: [],
-        StandingsUpdates: [],
-        ClassChanges: []
-    });
+export const getGuildLogController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "GuildId");
+    if (inventory.GuildId) {
+        const guild = await Guild.findById(inventory.GuildId);
+        if (guild) {
+            const log: Record<string, IGuildLogEntryClient[]> = {
+                RoomChanges: [],
+                TechChanges: [],
+                RosterActivity: [],
+                StandingsUpdates: [],
+                ClassChanges: []
+            };
+            guild.RoomChanges?.forEach(entry => {
+                log.RoomChanges.push({
+                    dateTime: toMongoDate(entry.dateTime ?? new Date()),
+                    entryType: entry.entryType,
+                    details: entry.details
+                });
+            });
+            guild.TechChanges?.forEach(entry => {
+                log.TechChanges.push({
+                    dateTime: toMongoDate(entry.dateTime ?? new Date()),
+                    entryType: entry.entryType,
+                    details: entry.details
+                });
+            });
+            guild.RosterActivity?.forEach(entry => {
+                log.RosterActivity.push({
+                    dateTime: toMongoDate(entry.dateTime),
+                    entryType: entry.entryType,
+                    details: entry.details
+                });
+            });
+            guild.ClassChanges?.forEach(entry => {
+                log.ClassChanges.push({
+                    dateTime: toMongoDate(entry.dateTime),
+                    entryType: entry.entryType,
+                    details: entry.details
+                });
+            });
+            res.json(log);
+            return;
+        }
+    }
+    res.sendStatus(200);
 };
+
+interface IGuildLogEntryClient {
+    dateTime: IMongoDate;
+    entryType: number;
+    details: number | string;
+}

src/controllers/api/getIgnoredUsersController.ts

@@ -1,16 +1,20 @@
-import { RequestHandler } from "express";
+import { toOid } from "../../helpers/inventoryHelpers.ts";
+import { Account, Ignore } from "../../models/loginModel.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import type { IFriendInfo } from "../../types/friendTypes.ts";
+import { parallelForeach } from "../../utils/async-utils.ts";
+import type { RequestHandler } from "express";
 
-const getIgnoredUsersController: RequestHandler = (_req, res) => {
-    res.writeHead(200, {
-        "Content-Type": "text/html",
-        "Content-Length": "3"
+export const getIgnoredUsersController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const ignores = await Ignore.find({ ignorer: accountId });
+    const ignoredUsers: IFriendInfo[] = [];
+    await parallelForeach(ignores, async ignore => {
+        const ignoreeAccount = (await Account.findById(ignore.ignoree, "DisplayName"))!;
+        ignoredUsers.push({
+            _id: toOid(ignore.ignoree),
+            DisplayName: ignoreeAccount.DisplayName + ""
+        });
     });
-    res.end(
-        Buffer.from([
-            0x7b, 0x22, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x38, 0x33, 0x30, 0x34, 0x30, 0x37, 0x37, 0x32, 0x32,
-            0x34, 0x30, 0x32, 0x32, 0x32, 0x36, 0x31, 0x35, 0x30, 0x31, 0x7d
-        ])
-    );
+    res.json({ IgnoredUsers: ignoredUsers });
 };
-
-export { getIgnoredUsersController };

src/controllers/api/getNewRewardSeedController.ts

@@ -1,13 +1,19 @@
-import { RequestHandler } from "express";
+import { Inventory } from "../../models/inventoryModels/inventoryModel.ts";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { generateRewardSeed } from "../../services/rngService.ts";
+import type { RequestHandler } from "express";
 
-const getNewRewardSeedController: RequestHandler = (_req, res) => {
-    res.json({ rewardSeed: generateRewardSeed() });
+export const getNewRewardSeedController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+
+    const rewardSeed = generateRewardSeed();
+    await Inventory.updateOne(
+        {
+            accountOwnerId: accountId
+        },
+        {
+            RewardSeed: rewardSeed
+        }
+    );
+    res.json({ rewardSeed: rewardSeed });
 };
-
-function generateRewardSeed(): number {
-    const min = -Number.MAX_SAFE_INTEGER;
-    const max = Number.MAX_SAFE_INTEGER;
-    return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-
-export { getNewRewardSeedController };

src/controllers/api/getPastWeeklyChallengesController.ts

@@ -0,0 +1,62 @@
+import type { RequestHandler } from "express";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { getInventory } from "../../services/inventoryService.ts";
+import { getSeasonChallengePools, getWorldState, pushWeeklyActs } from "../../services/worldStateService.ts";
+import { EPOCH, unixTimesInMs } from "../../constants/timeConstants.ts";
+import type { ISeasonChallenge } from "../../types/worldStateTypes.ts";
+import { ExportChallenges } from "warframe-public-export-plus";
+
+export const getPastWeeklyChallengesController: RequestHandler = async (req, res) => {
+    const accountId = await getAccountIdForRequest(req);
+    const inventory = await getInventory(accountId, "SeasonChallengeHistory ChallengeProgress");
+    const worldState = getWorldState(undefined);
+
+    if (worldState.SeasonInfo) {
+        const pools = getSeasonChallengePools(worldState.SeasonInfo.AffiliationTag);
+        const nightwaveStartTimestamp = Number(worldState.SeasonInfo.Activation.$date.$numberLong);
+        const nightwaveSeason = worldState.SeasonInfo.Season;
+        const timeMs = worldState.Time * 1000;
+        const completedChallengesIds = new Set<string>();
+
+        inventory.SeasonChallengeHistory.forEach(challengeHistory => {
+            const entryNightwaveSeason = parseInt(challengeHistory.id.slice(0, 4), 10) - 1;
+            if (nightwaveSeason == entryNightwaveSeason) {
+                const meta = Object.entries(ExportChallenges).find(
+                    ([key]) => key.split("/").pop() === challengeHistory.challenge
+                );
+                if (meta) {
+                    const [, challengeMeta] = meta;
+                    const challengeProgress = inventory.ChallengeProgress.find(
+                        c => c.Name === challengeHistory.challenge
+                    );
+
+                    if (challengeProgress && challengeProgress.Progress >= (challengeMeta.requiredCount ?? 1)) {
+                        completedChallengesIds.add(challengeHistory.id);
+                    }
+                }
+            }
+        });
+
+        const PastWeeklyChallenges: ISeasonChallenge[] = [];
+
+        let week = Math.trunc((timeMs - EPOCH) / unixTimesInMs.week) - 1;
+
+        while (EPOCH + week * unixTimesInMs.week >= nightwaveStartTimestamp && PastWeeklyChallenges.length < 3) {
+            const tempActs: ISeasonChallenge[] = [];
+            pushWeeklyActs(tempActs, pools, week, nightwaveStartTimestamp, nightwaveSeason);
+
+            for (const act of tempActs) {
+                if (!completedChallengesIds.has(act._id.$oid) && PastWeeklyChallenges.length < 3) {
+                    if (act.Challenge.startsWith("/Lotus/Types/Challenges/Seasons/Weekly/SeasonWeeklyPermanent")) {
+                        act.Permanent = true;
+                    }
+                    PastWeeklyChallenges.push(act);
+                }
+            }
+
+            week--;
+        }
+
+        res.json({ PastWeeklyChallenges: PastWeeklyChallenges });
+    }
+};

src/controllers/api/getShipController.ts

@@ -1,50 +1,33 @@
-import { RequestHandler } from "express";
-import { config } from "@/src/services/configService";
-import allShipFeatures from "@/static/fixed_responses/allShipFeatures.json";
-import { getAccountIdForRequest } from "@/src/services/loginService";
-import { getPersonalRooms } from "@/src/services/personalRoomsService";
-import { getShip } from "@/src/services/shipService";
-import { Loadout } from "@/src/models/inventoryModels/loadoutModel";
-import { logger } from "@/src/utils/logger";
-import { toOid } from "@/src/helpers/inventoryHelpers";
-import { IGetShipResponse } from "@/src/types/shipTypes";
+import type { RequestHandler } from "express";
+import { getAccountIdForRequest } from "../../services/loginService.ts";
+import { createGarden, getPersonalRooms } from "../../services/personalRoomsService.ts";
+import type { IGetShipResponse, IPersonalRoomsClient } from "../../types/personalRoomsTypes.ts";
+import { getLoadout } from "../../services/loadoutService.ts";
+import { toOid } from "../../helpers/inventoryHelpers.ts";
 
-// eslint-disable-next-line @typescript-eslint/no-misused-promises
 export const getShipController: RequestHandler = async (req, res) => {
     const accountId = await getAccountIdForRequest(req);
-    const personalRooms = await getPersonalRooms(accountId);
+    const personalRoomsDb = await getPersonalRooms(accountId);
+
+    // Setup gardening if it's missing. Maybe should be done as part of some quest completion in the future.
+    if (personalRoomsDb.Apartment.Gardening.Planters.length == 0) {
+        personalRoomsDb.Apartment.Gardening = createGarden();
+        await personalRoomsDb.save();
+    }
+
+    const personalRooms = personalRoomsDb.toJSON<IPersonalRoomsClient>();
     const loadout = await getLoadout(accountId);
-    const ship = await getShip(personalRooms.activeShipId, "ShipInteriorColors ShipAttachments SkinFlavourItem");
 
     const getShipResponse: IGetShipResponse = {
         ShipOwnerId: accountId,
         LoadOutInventory: { LoadOutPresets: loadout.toJSON() },
         Ship: {
-            ...personalRooms.toJSON().Ship,
-            ShipId: toOid(personalRooms.activeShipId),
-            ShipInterior: {
-                Colors: ship.ShipInteriorColors,
-                ShipAttachments: ship.ShipAttachments,
-                SkinFlavourItem: ship.SkinFlavourItem
-            }
+            ...personalRooms.Ship,
+            ShipId: toOid(personalRoomsDb.activeShipId)
         },
-        Apartment: personalRooms.Apartment
+        Apartment: personalRooms.Apartment,
+        TailorShop: personalRooms.TailorShop
     };
 
-    if (config.unlockAllShipFeatures) {
-        getShipResponse.Ship.Features = allShipFeatures;
-    }
-
     res.json(getShipResponse);
 };
-
-export const getLoadout = async (accountId: string) => {
-    const loadout = await Loadout.findOne({ loadoutOwnerId: accountId });
-
-    if (!loadout) {
-        logger.error(`loadout not found for account ${accountId}`);
-        throw new Error("loadout not found");
-    }
-
-    return loadout;
-};