added formatting config and formatted code to follow it

.editorconfig

···
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+indent_style = tab
+indent_size = 4
+tab_width = 4
+max_line_length = 100
+
+
+[*.{html,htm}]
+max_line_length = 1000 # easier to know where you are

.rustfmt.toml

···
+# because rustfmt refuses to follow .editorconfig
+hard_tabs = true
+tab_spaces = 4
+max_width = 100
+use_small_heuristics = "Max"

app/src-tauri/src/lib.rs

···
 // Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
 #[tauri::command]
 fn greet(name: &str) -> String {
-    format!("Hello, {}! You've been greeted from Rust!", name)
+	format!("Hello, {}! You've been greeted from Rust!", name)
 }
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
-    tauri::Builder::default()
-        .setup(|app| {
-            let app_handle = app.handle();
-            let store_path = PathBuf::from("settings.json");
-            let store = StoreBuilder::new(app_handle, store_path).build()?;
+	tauri::Builder::default()
+		.setup(|app| {
+			let app_handle = app.handle();
+			let store_path = PathBuf::from("settings.json");
+			let store = StoreBuilder::new(app_handle, store_path).build()?;
 
-            let user_id = store.get("user_id");
+			let user_id = store.get("user_id");
 
-            let page = if user_id.is_some() {
-                "/src/home-page/home.html"
-            } else {
-                "/src/signup-page/signup.html"
-            };
+			let page = if user_id.is_some() {
+				"/src/home-page/home.html"
+			} else {
+				"/src/signup-page/signup.html"
+			};
 
-            // create and open window directly at the correct page
-            WebviewWindowBuilder::new(app_handle, "main", WebviewUrl::App(page.into()))
-                .title("privacypin")
-                .inner_size(412.0, 715.0)
-                .resizable(false)
-                .build()?;
+			// create and open window directly at the correct page
+			WebviewWindowBuilder::new(app_handle, "main", WebviewUrl::App(page.into()))
+				.title("privacypin")
+				.inner_size(412.0, 715.0)
+				.resizable(false)
+				.build()?;
 
-            Ok(())
-        })
-        .plugin(tauri_plugin_store::Builder::default().build())
-        .invoke_handler(tauri::generate_handler![greet])
-        .run(tauri::generate_context!())
-        .expect("error while running tauri application");
+			Ok(())
+		})
+		.plugin(tauri_plugin_store::Builder::default().build())
+		.invoke_handler(tauri::generate_handler![greet])
+		.run(tauri::generate_context!())
+		.expect("error while running tauri application");
 }

app/src-tauri/src/main.rs

···
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 fn main() {
-    privacypin_lib::run()
+	privacypin_lib::run()
 }

app/src/add-friend-page/add-friend.html

···
 
 				<div class="card">
 					<label for="friendUserId">Friend user id</label>
-					<input
-						id="friendUserId"
-						type="text"
-						x-model="friend_id"
-						placeholder="Enter their user id"
-					/>
+					<input id="friendUserId" type="text" x-model="friend_id" placeholder="Enter their user id" />
 
 					<label for="friendKey">Friend key</label>
-					<input
-						id="friendKey"
-						type="text"
-						x-model="friend_rand_key"
-						placeholder="Enter their key"
-					/>
+					<input id="friendKey" type="text" x-model="friend_rand_key" placeholder="Enter their key" />
 
 					<label for="friendName">Friend Name</label>
-					<input
-						id="friendName"
-						type="text"
-						x-model="friend_name"
-						placeholder="Enter their name"
-					/>
+					<input id="friendName" type="text" x-model="friend_name" placeholder="Enter their name" />
 
-					<button
-						class="primary"
-						x-bind:disabled="is_doing_stuff"
-						@click="sendFriendRequest()"
-					>
-						Send friend request
-					</button>
+					<button class="primary" x-bind:disabled="is_doing_stuff" @click="sendFriendRequest()">Send friend request</button>
 				</div>
 			</div>
 		</div>

app/src/home-page/home.html

···
 					<!-- <@azom.dev> somehow the "+" emoji does not display in the code for me, but it's temporary anyways -->
 					<!-- <@kishka.cc> we will need to replace these with svgs, as it's the font that messes up the emoji -->
 					<button class="icon-btn" @click="updateServer()">
-						<img
-							class="svg-icon"
-							src="/src/assets/paperplane.svg"
-							alt="Paperplane Flying Icon"
-						/>
+						<img class="svg-icon" src="/src/assets/paperplane.svg" alt="Paperplane Flying Icon" />
 					</button>
 					<button class="icon-btn" @click="addFriend()">
 						<img class="svg-icon" src="/src/assets/user+.svg" alt="Friend Add Icon" />
···
 			<div class="content">
 				<div class="friends-header">
 					<h2 style="font-size: 1rem; margin: 0">Friends</h2>
-					<span style="color: #6b7280; font-size: 0.9rem"
-						>(<span x-text="friends.length"></span>)</span
-					>
+					<span style="color: #6b7280; font-size: 0.9rem">(<span x-text="friends.length"></span>)</span>
 				</div>
 				<!--TODO idk why but sometimes when i launch the app I see the stuff when you have no friends for a split second before I see them appear, even tho we get them in init -->
 				<template x-if="friends.length > 0">
···
 							<div class="friend-card">
 								<strong x-text="friend.name"></strong>
 								<div class="friend-actions">
-									<button class="view-btn" @click="viewLocation(friend.id)">
-										<img
-											class="svg-icon"
-											src="/src/assets/pin-location.svg"
-											alt="Pin Icon"
-										/>View
+									<button class="view-btn" @click="viewLocation(friend.id)"><img class="svg-icon" src="/src/assets/pin-location.svg" alt="Pin Icon" />View</button>
+
+									<button class="menu-icon" style="margin-bottom: auto" @click="friendOptions(friend.id)">
+										<img class="svg-icon" src="/src/assets/ellipsis-vertical.svg" alt="Options menu" />
 									</button>
-									<a
-										class="menu-icon"
-										style="margin-bottom: auto"
-										@click="friendOptions(friend.id)"
-									>
-										<img
-											class="svg-icon"
-											src="/src/assets/ellipsis-vertical.svg"
-											alt="Options menu"
-										/>
-									</a>
 								</div>
 							</div>
 						</template>

app/src/settings-page/settings.html

···
 			<div class="actions" x-data="settingsPageState">
 				<h3>Settings</h3>
 
-				<button class="btn-primary" @click="goto('home')">
-					Back to Home
-				</button>
+				<button class="btn-primary" @click="goto('home')">Back to Home</button>
 
-				<button class="btn-secondary" @click="await debugLogout()">
-					Signout
-				</button>
+				<button class="btn-secondary" @click="await debugLogout()">Signout</button>
 			</div>
 		</div>
 	</body>

app/src/signup-page/signup.html

···
 					Scan QR Code
 				</button>
 
-				<button class="btn-primary" x-bind:disabled="isDoingStuff" @click="await signup()"><span x-show="isDoingStuff">Connecting...</span> <span x-show="!isDoingStuff">Connect</span></button>
+				<button class="btn-primary" x-bind:disabled="isDoingStuff" @click="await signup()">
+					<span x-show="isDoingStuff">Connecting...</span>
+					<span x-show="!isDoingStuff">Connect</span>
+				</button>
 			</div>
 		</div>
 	</body>

app/src/utils/tools.ts

···
 export function goto(newLocation: string) {
-	window.location.href =
-		"/src/" + newLocation + "-page/" + newLocation + ".html";
+	window.location.href = "/src/" + newLocation + "-page/" + newLocation + ".html";
 }

app/tsconfig.json

···
 		// TODO: does that break stuff?
 		"baseUrl": "./src",
 		"paths": {
-			"@utils/*": ["utils/*"]
-		}
+			"@utils/*": ["utils/*"],
+		},
 	},
-	"include": ["src"]
+	"include": ["src"],
 }

server/.rustfmt.toml

···
-hard_tabs = true

server/src/auth.rs

···
 
 		let users = state.users.lock().await;
 		let user_id = auth_data.user_id;
-		let user = users
-			.iter()
-			.find(|u| u.id == user_id)
-			.ok_or(SrvErr!("User not found"))?;
+		let user = users.iter().find(|u| u.id == user_id).ok_or(SrvErr!("User not found"))?;
 		let verifying_key = user.pub_key.clone();
 
 		// NOTE (key chaining):
···
 		let sig_vec = BASE64_STANDARD
 			.decode(&auth_data.signature)
 			.map_err(|e| SrvErr!("base64 decode fail", e))?;
-		let sig_bytes: [u8; 64] = sig_vec
-			.try_into()
-			.map_err(|e| SrvErr!("invalid signature length", e))?;
+		let sig_bytes: [u8; 64] =
+			sig_vec.try_into().map_err(|e| SrvErr!("invalid signature length", e))?;
 		let signature = Signature::from_bytes(&sig_bytes);
 
 		if let Err(err) = verifying_key.verify_strict(&body_bytes, &signature) {

server/src/handlers.rs

···
 	};
 
 	// todo check
-	let pub_key_arr: [u8; 32] = pub_key_bytes
-		.as_slice()
-		.try_into()
-		.map_err(|_| SrvErr!("Invalid pubkey length"))?;
+	let pub_key_arr: [u8; 32] =
+		pub_key_bytes.as_slice().try_into().map_err(|_| SrvErr!("Invalid pubkey length"))?;
 	let pub_key = VerifyingKey::from_bytes(&pub_key_arr)
 		.map_err(|e| SrvErr!("Invalid public key bytes", e))?;
 
···
 		admin_id_guard.replace(user_id.clone());
 	}
 
-	users.push(User {
-		id: user_id.clone(),
-		pub_key,
-	});
+	users.push(User { id: user_id.clone(), pub_key });
 
 	return Ok(Json(CreateAccountResponse { user_id, is_admin }));
 }
···
 	}
 
 	let mut friend_requests = state.friend_requests.lock().await;
-	let mut friend_request_link = DirectedFriendRequestLink {
-		sender_id: friend_id,
-		accepter_id: user_id,
-	};
+	let mut friend_request_link =
+		DirectedFriendRequestLink { sender_id: friend_id, accepter_id: user_id };
 
 	// if we remove sucessfully the link, it means a request already existed
 	// so we are making the friendship official
···
 
 	for ping in pings {
 		let link = UndirectedLink::new(user_id.clone(), ping.receiver_id.clone());
-		pings_state
-			.get_mut(&link)
-			.unwrap()
-			.add(EncryptedPing(ping.encrypted_ping)); // We assured that a ringbuffer exists because it was created when the link was created, hence the .unwrap()
+		pings_state.get_mut(&link).unwrap().add(EncryptedPing(ping.encrypted_ping)); // We assured that a ringbuffer exists because it was created when the link was created, hence the .unwrap()
 	}
 
 	return Ok(());

server/src/log.rs

···
 	middleware::Next,
 	response::Response,
 };
+
 use base64::{Engine, prelude::BASE64_STANDARD};
 use serde_json::Value;
 
···
 	let s = v.to_str().ok()?.to_string();
 
 	const MAX: usize = 120;
-	if s.len() > MAX {
-		Some(format!("{}… (len={})", &s[..MAX], s.len()))
-	} else {
-		Some(s)
-	}
+	if s.len() > MAX { Some(format!("{}… (len={})", &s[..MAX], s.len())) } else { Some(s) }
 }
 
 fn status_emoji(status: axum::http::StatusCode) -> &'static str {

server/src/main.rs

···
 		.route("/create-account", post(create_user))
 		.route("/generate-signup-key", post(generate_signup_key))
 		.route("/request-friend-request", post(request_friend_request))
-		.route(
-			"/is-friend-request-accepted",
-			post(is_friend_request_accepted),
-		)
+		.route("/is-friend-request-accepted", post(is_friend_request_accepted))
 		.route("/send-pings", post(send_pings))
 		.route("/get-pings", post(get_pings))
 		.with_state(state.clone())

server/src/types.rs

···
 // represents a ring buffer for a directed friend connection (ex.: user1 sending to user2, which in that case it's only user1's positions)
 impl RingBuffer {
 	pub fn new(capacity: usize) -> Self {
-		return Self {
-			ring: vec![None; capacity].into_boxed_slice(),
-			idx: 0,
-		};
+		return Self { ring: vec![None; capacity].into_boxed_slice(), idx: 0 };
 	}
 
 	pub fn add(&mut self, p: EncryptedPing) {
···
 
 impl UndirectedLink {
 	pub fn new(a: String, b: String) -> Self {
-		if a < b {
-			UndirectedLink(a, b)
-		} else {
-			UndirectedLink(b, a)
-		} // normalize order
+		if a < b { UndirectedLink(a, b) } else { UndirectedLink(b, a) } // normalize order
 	}
 
 	pub fn from(dfrl: DirectedFriendRequestLink) -> Self {
···
 
 /// Central policy: what gets logged, what gets returned.
 pub fn mk_srv_err(msg: impl Into<String>, cause: Option<String>) -> SrvErr {
-	SrvErr {
-		msg: msg.into(),
-		cause,
-	}
+	SrvErr { msg: msg.into(), cause }
 }
 
 #[macro_export]

server/test/test.test.ts

···
 
 		const res3 = await post("get-pings", user, admin.user_id);
 
-		expect(JSON.parse(res3)).toEqual(["this is definitely encrypted trust #2", "this is definitely encrypted trust #1"]);
+		expect(JSON.parse(res3)).toEqual([
+			"this is definitely encrypted trust #2",
+			"this is definitely encrypted trust #1",
+		]);
 	});
 });

server/test/utils.ts

···
 export const URL = "http://127.0.0.1:3000";
 
 // Generate an Ed25519 keypair and register it with the server.
-export async function generateUser(signup_key: string | undefined, should_be_admin: boolean = false): Promise<{ user_id: string; pubKey: Uint8Array; privKey: Uint8Array }> {
+export async function generateUser(
+	signup_key: string | undefined,
+	should_be_admin: boolean = false,
+): Promise<{ user_id: string; pubKey: Uint8Array; privKey: Uint8Array }> {
 	if (!signup_key) {
 		throw new Error("signup_key was not provided or captured from server output");
 	}
···
 	return { user_id: json.user_id, pubKey, privKey };
 }
 
-export async function post(endpoint: string, user: { user_id: string; privKey: Uint8Array }, data: Object | string | undefined): Promise<any> {
+export async function post(
+	endpoint: string,
+	user: { user_id: string; privKey: Uint8Array },
+	data: Object | string | undefined,
+): Promise<any> {
 	let bodyBytes: Uint8Array;
 
 	if (typeof data === "object") {
···
 	}
 
 	// Sign body using private key
-	const privateKey = await crypto.subtle.importKey("pkcs8", user.privKey.buffer, { name: "Ed25519" }, false, ["sign"]);
+	const privateKey = await crypto.subtle.importKey(
+		"pkcs8",
+		user.privKey.buffer,
+		{ name: "Ed25519" },
+		false,
+		["sign"],
+	);
 
 	const signature = new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, bodyBytes));
 	const signature_b64 = btoa(String.fromCharCode(...signature));