feat: adds incoming PDUs processing

Author: ricardogarim

.husky/pre-commit

@@ -1,4 +1,3 @@
 bun lint
 bunx tsc
-bun test
-
+bun test

bun.lock

@@ -1,58 +1,30 @@
-// // /v2/server/{keyID}
-// // /v2/server/
-// // /v2/server
+import { HomeserverModule } from '@hs/homeserver/src/homeserver.module';
+import { HttpLoggerInterceptor } from '@hs/homeserver/src/middleware/http-logger.interceptor';
+import { ConfigService } from '@hs/homeserver/src/services/config.service';
+import { NestFactory } from '@nestjs/core';
+import 'reflect-metadata';
 
-// // /v2/query
-// // /v2/query/{serverName}/{keyID}
-// // /v1/send/{txnID}
+async function bootstrap() {
+  try {
+    const nestApp = await NestFactory.create(HomeserverModule, {
+      logger: ['error', 'warn', 'log', 'debug'],
+    });
+    
+    nestApp.useGlobalInterceptors(new HttpLoggerInterceptor());
+    
+    await nestApp.init();
 
-// // /v1/invite/{roomID}/{eventID}
-// // /v2/invite/{roomID}/{eventID}
-// // /v3/invite/{roomID}/{userID}
-// // /v1/3pid/onbind
-// // /v1/exchange_third_party_invite/{roomID}
-// // /v1/event/{eventID}
-// // /v1/state/{roomID}
-// // /v1/state_ids/{roomID}
-// // /v1/event_auth/{roomID}/{eventID}
-// // /v1/query/directory
-// // /v1/query/profile
-// // /v1/user/devices/{userID}
-// // /v1/peek/{roomID}/{peekID}
-// // /v1/make_join/{roomID}/{userID}
-// // /v1/send_join/{roomID}/{eventID}
-// // /v2/send_join/{roomID}/{eventID}
-// // /v1/make_leave/{roomID}/{userID}
-// // /v1/send_leave/{roomID}/{eventID}
-// // /v2/send_leave/{roomID}/{eventID}
-// // /v1/version
-// // /v1/get_missing_events/{roomID}
-// // /v1/backfill/{roomID}
-// // /v1/publicRooms
-// // /v1/user/keys/claim
-// // /v1/user/keys/query
-// // /v1/openid/userinfo
-// // /v1/hierarchy/{roomID}
+    const configService = nestApp.get(ConfigService);
+    
+    const port = configService.getServerConfig().port;
+    const host = configService.getServerConfig().host;
+    
+    nestApp.listen(port, () => {
+      console.log(`🚀 App running on http://${host}:${port}`);
+    });
+  } catch (error) {
+    console.error('Error setting up the application:', error);
+  }
+}
 
-import Elysia from "elysia";
-import { app } from "@hs/homeserver";
-import { fakeEndpoints } from "@hs/fake";
-import { routerWithMongodb } from "@hs/homeserver/src/plugins/mongodb";
-
-import { config } from "./config";
-import { db } from "./mongo";
-
-new Elysia({
-	handler: {
-		standardHostname: false,
-	},
-})
-	.decorate("config", config)
-	.use(routerWithMongodb(db))
-	.use(app)
-	.use(fakeEndpoints)
-	.listen(config.port, (context) => {
-		console.log(
-			`🦊 Homeserver is running at http://${context.hostname}:${context.port}`,
-		);
-	});
+bootstrap();

bun.lockb

@@ -1,40 +1,45 @@
 {
-	"name": "homeserver",
-	"module": "index.ts",
-	"private": true,
-	"type": "module",
-	"devDependencies": {
-		"@biomejs/biome": "^1.9.4",
-		"@types/bun": "latest",
-		"husky": "^9.1.7"
-	},
-	"peerDependencies": {
-		"typescript": "^5.0.0"
-	},
-	"workspaces": ["packages/*"],
-	"dependencies": {
-		"@bogeychan/elysia-etag": "^0.0.6",
-		"@bogeychan/elysia-logger": "^0.1.4",
-		"@elysiajs/swagger": "^1.1.6",
-		"@hs/fake": "workspace:*",
-		"@hs/homeserver": "workspace:*",
-		"bun-bagel": "^1.1.0",
-		"elysia": "^1.1.26",
-		"mongodb": "^6.11.0",
-		"node-jsonwebtoken": "^0.0.1",
-		"tweetnacl": "^1.0.3"
-	},
-	"husky": {
-		"hooks": {
-			"pre-commit": "bun test"
-		}
-	},
-	"scripts": {
-		"prepare": "husky",
-		"start": "bun run index.ts",
-		"test": "bun test",
-		"test:coverage": "bun test --coverage",
-		"lint": "bunx @biomejs/biome lint",
-		"tsc": "bunx tsc"
-	}
-}
+  "name": "homeserver",
+  "module": "index.ts",
+  "private": true,
+  "type": "module",
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/bun": "latest",
+    "husky": "^9.1.7"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "workspaces": ["packages/*"],
+  "dependencies": {
+    "@bogeychan/elysia-etag": "^0.0.6",
+    "@bogeychan/elysia-logger": "^0.1.4",
+    "@elysiajs/swagger": "^1.1.6",
+    "@hs/fake": "workspace:*",
+    "@hs/homeserver": "workspace:*",
+    "@nestjs/common": "^11.1.0",
+    "@nestjs/core": "^11.1.0",
+    "bun-bagel": "^1.1.0",
+    "dotenv": "^16.5.0",
+    "elysia": "^1.1.26",
+    "mongodb": "^6.11.0",
+    "node-jsonwebtoken": "^0.0.1",
+    "reflect-metadata": "^0.2.2",
+    "tweetnacl": "^1.0.3",
+    "zod": "^3.24.3"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "bun test"
+    }
+  },
+  "scripts": {
+    "prepare": "husky",
+    "start": "bun run index.ts",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage",
+    "lint": "bunx @biomejs/biome lint",
+    "tsc": "bunx tsc"
+  }
+}

index.ts

@@ -0,0 +1,152 @@
+# Matrix Federation SDK
+
+A simple SDK for Matrix server-to-server communication. This SDK provides a clean interface for making Matrix federation API calls, handling the complex authentication and request signing required by the Matrix specification.
+
+## Features
+
+- Simple, Promise-based API for all Matrix federation endpoints
+- Automatic request signing and authentication
+- DNS-based server discovery
+- Typed responses using Zod schemas
+- Comprehensive error handling
+
+## Installation
+
+```bash
+# From project root
+cd homeserver/packages/federation-sdk
+npm install
+npm run build
+```
+
+## Usage
+
+### Basic Setup
+
+```typescript
+import { FederationClient } from '@hs/federation-sdk';
+import { generateKeyPairsFromString } from '../../homeserver/src/keys';
+
+// Create signing key
+const signingKey = await generateKeyPairsFromString(
+  "ed25519 myKey yourPrivateKeyHere"
+);
+
+// Create federation client
+const client = new FederationClient({
+  serverName: "your-server.com",
+  signingKey: signingKey,
+  debug: true // Optional, enables detailed logging
+});
+```
+
+### Getting Server Version
+
+```typescript
+const targetServer = "matrix.org";
+
+try {
+  const version = await client.getVersion(targetServer);
+  console.log(`Server version: ${version.server.name} ${version.server.version}`);
+} catch (error) {
+  console.error(`Error getting version: ${error}`);
+}
+```
+
+### Querying Room State
+
+```typescript
+const targetServer = "matrix.org";
+const roomId = "!someRoomId:matrix.org";
+
+try {
+  // First get room version
+  const roomVersion = await client.getRoomVersion(targetServer, roomId);
+  console.log(`Room version: ${roomVersion}`);
+  
+  // Get state IDs
+  const stateIds = await client.getStateIds(targetServer, roomId);
+  console.log(`Room has ${stateIds.pdu_ids.length} state events`);
+  
+  if (stateIds.pdu_ids.length > 0) {
+    // Use an event ID to get room state (required by most servers)
+    const eventId = stateIds.pdu_ids[0];
+    
+    // Get full state using a reference event ID
+    const state = await client.getState(targetServer, roomId, undefined, undefined, eventId);
+    console.log(`Got ${state.pdus.length} state events`);
+    
+    // Get specific state type
+    const powerLevels = await client.getState(
+      targetServer, 
+      roomId, 
+      "m.room.power_levels", 
+      "", 
+      eventId
+    );
+    console.log("Power levels:", powerLevels);
+  }
+} catch (error) {
+  console.error(`Error querying room: ${error}`);
+}
+```
+
+### Sending Events
+
+```typescript
+const targetServer = "matrix.org";
+const event = {
+  type: "m.room.message",
+  room_id: "!someRoomId:matrix.org",
+  sender: "@youruser:your-server.com",
+  content: {
+    msgtype: "m.text",
+    body: "Hello from Federation SDK!"
+  },
+  // other required fields
+};
+
+try {
+  const response = await client.sendEvent(targetServer, event);
+  console.log("Event sent successfully:", response);
+} catch (error) {
+  console.error(`Error sending event: ${error}`);
+}
+```
+
+### Room Joining Flow
+
+```typescript
+const targetServer = "matrix.org";
+const roomId = "!someRoomId:matrix.org";
+const userId = "@youruser:your-server.com";
+
+try {
+  // 1. Prepare to join
+  const makeJoinResponse = await client.makeJoin(targetServer, roomId, userId);
+  console.log(`Got make_join response with room version ${makeJoinResponse.room_version}`);
+  
+  // 2. Complete the event (sign it, add hashes, etc.)
+  const joinEvent = completeJoinEvent(makeJoinResponse.event);
+  
+  // 3. Send the join
+  const sendJoinResponse = await client.sendJoin(
+    targetServer, 
+    roomId, 
+    joinEvent.event_id, 
+    joinEvent
+  );
+  
+  console.log(`Join successful! Got ${sendJoinResponse.state.length} state events`);
+} catch (error) {
+  console.error(`Join failed: ${error}`);
+}
+```
+
+## API Documentation
+
+See the [Matrix Federation API Specification](https://spec.matrix.org/v1.7/server-server-api/) for more details on the underlying protocol.
+
+## License
+
+MIT

package.json

@@ -0,0 +1,49 @@
+import fs from 'fs';
+import { generateKeyPairsFromString } from '../../homeserver/src/keys';
+import { FederationClient } from '../src';
+
+async function main() {
+  const serverName = process.env.SERVER_NAME || 'your-server.example.com';
+  
+  const keyString = process.env.SIGNING_KEY || 
+    fs.readFileSync('./signing-key.txt', 'utf-8').trim();
+  
+  try {
+    const signingKey = await generateKeyPairsFromString(keyString);
+    
+    const federation = new FederationClient({
+      serverName,
+      signingKey,
+      debug: true
+    });
+    
+    const targetServer = process.env.TARGET_SERVER || 'matrix.org';
+    console.log(`Querying server: ${targetServer}`);
+    
+    try {
+      console.log('Getting server version...');
+      const version = await federation.getVersion(targetServer);
+      console.log(`Server version: ${version.server.name} ${version.server.version}`);
+    } catch (error) {
+      console.error('Error getting server version:', error);
+    }
+    
+    const userId = process.env.USER_ID || '@alice:matrix.org';
+    try {
+      console.log(`Querying profile for ${userId}...`);
+      const profile = await federation.queryProfile(targetServer, userId);
+      console.log('Profile data:', profile);
+    } catch (error) {
+      console.error('Error querying profile:', error);
+    }
+    
+  } catch (error) {
+    console.error('Fatal error:', error);
+    process.exit(1);
+  }
+}
+
+main().catch(error => {
+  console.error('Unhandled error:', error);
+  process.exit(1);
+});