New onboarding tests

package.json

@@ -8,6 +8,7 @@
   "devDependencies": {
     "@playwright/test": "^1.37.1",
     "@types/fs-extra": "^11.0.1",
+    "@types/libsodium-wrappers-sumo": "^0.7.8",
     "@types/lodash": "^4.14.196",
     "@types/uuid": "^9.0.8",
     "@typescript-eslint/eslint-plugin": "^6.2.1",
@@ -25,7 +26,8 @@
     "fs-extra": "^11.1.1",
     "lodash": "^4.17.21",
     "prettier": "^3.0.1",
-    "typescript": "^5.1.6",
+    "semver": "^7.5.4",
+    "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
   "scripts": {
@@ -35,5 +37,9 @@
     "allure-create": "allure generate ./allure-results",
     "allure-open": "allure open ./allure-report"
   },
-  "dependencies": {}
+  "dependencies": {
+    "buffer-crc32": "^1.0.0",
+    "libsodium-wrappers-sumo": "^0.7.14",
+    "session-tooling": "git+https://github.com/Bi1b/session-tooling"
+  }
 }

state_generation/actions/fetchSwarmOf.ts

@@ -0,0 +1,41 @@
+import { isEmpty, sample } from 'lodash';
+import { SwarmForSubRequest } from '../requests/snodeRequests';
+import { PubkeyType, Snode, SnodeFromSeed } from '../requests/types';
+
+const fetchedSwarms: Record<PubkeyType, Array<Snode>> = {};
+
+async function getSwarmOfUser(sessionId: PubkeyType, snode: SnodeFromSeed) {
+  const swarmRequest = new SwarmForSubRequest(sessionId);
+
+  const swarmResult = await fetch(
+    `https://${snode.public_ip}:${snode.storage_port}/storage_rpc/v1`,
+    {
+      body: JSON.stringify(await swarmRequest.build()),
+      method: 'POST',
+    },
+  );
+  const swarm = await swarmResult.json();
+
+  if (isEmpty(fetchedSwarms[sessionId])) {
+    fetchedSwarms[sessionId] = swarm;
+  }
+  // console.error('fetched userSwarm', swarm.snodes);
+
+  return swarm.snodes;
+}
+
+export async function randomSnodeOnUserSwarm(
+  sessionId: PubkeyType,
+  snode: SnodeFromSeed,
+) {
+  const userSwarm =
+    fetchedSwarms[sessionId] || (await getSwarmOfUser(sessionId, snode));
+  const randomSnodeOnSwarm = sample(userSwarm);
+  if (!randomSnodeOnSwarm) {
+    throw new Error(`did not find a snode for user: ${sessionId}`);
+  }
+  console.info(
+    `random snode for user: ${sessionId} is snode: ${randomSnodeOnSwarm.pubkey_ed25519}`,
+  );
+  return randomSnodeOnSwarm;
+}

state_generation/index.ts

@@ -0,0 +1,131 @@
+import { sample } from 'lodash';
+import { getSodiumNode, WithSodium } from '../tests/sodium';
+import { randomSnodeOnUserSwarm } from './actions/fetchSwarmOf';
+
+import { getAllSnodesFromSeed } from './requests/seedRequest';
+import { PubkeyType } from './requests/types';
+import { loadSessionTools, WithSessionTools } from './sessionTools';
+import { createRandomUser, SessionUser } from './sessionUser';
+
+function createRandomLegacyGroup({ sodium }: WithSodium) {
+  const seed = sodium.randombytes_buf(sodium.crypto_sign_ed25519_SEEDBYTES);
+  const ed25519KeyPair = sodium.crypto_sign_seed_keypair(seed);
+  const privkeyHex = sodium.to_hex(ed25519KeyPair.privateKey);
+
+  // 64 privkey + 64 pubkey
+  const publicKey = sodium.crypto_sign_ed25519_sk_to_pk(
+    sodium.from_hex(privkeyHex),
+  );
+  const x25519Pk = sodium.crypto_sign_ed25519_pk_to_curve25519(publicKey);
+
+  const encKeypair = sodium.crypto_sign_keypair();
+  const groupPubkey = new Uint8Array(33);
+  groupPubkey.set(x25519Pk, 1);
+  groupPubkey[0] = 5;
+
+  const groupPk = sodium.to_hex(groupPubkey) as PubkeyType;
+  return {
+    groupPk,
+    encPk: encKeypair.publicKey,
+    encSk: encKeypair.privateKey,
+  };
+}
+// type CreatedLegacyGroup = ReturnType<typeof createRandomLegacyGroup>;
+
+function makeFriendsAndKnown(...users: Array<SessionUser>) {
+  if (users.length < 2) {
+    throw new Error('needs at least two users to make them friends');
+  }
+  users.forEach((user1, index) => {
+    const user2 = users[index + 1];
+    if (user2) {
+      user1.contacts.setApproved(user2.sessionId, true);
+      user1.contacts.setApprovedMe(user2.sessionId, true);
+      user2.contacts.setApproved(user1.sessionId, true);
+      user2.contacts.setApprovedMe(user1.sessionId, true);
+      user2.contacts.setName(
+        user1.sessionId,
+        user1.userProfile.getName() || '',
+      );
+      user1.contacts.setName(
+        user2.sessionId,
+        user2.userProfile.getName() || '',
+      );
+    }
+  });
+}
+
+function makeGroupWithMembers({
+  members,
+  groupName,
+  sodium,
+}: {
+  members: Array<SessionUser>;
+  groupName: string;
+} & WithSodium) {
+  // first one is the creator
+  if (!members.length) {
+    throw new Error('Excepted at least one creator/member');
+  }
+  const [creator, ...otherMembers] = members;
+  const { encPk, encSk, groupPk } = createRandomLegacyGroup({ sodium });
+  const legacyGroup = creator.userGroups.getOrConstructLegacyGroup(groupPk);
+  legacyGroup.name = groupName;
+  legacyGroup.encPubkey = encPk;
+  legacyGroup.encSeckey = encSk;
+  legacyGroup.insert(creator.sessionId, true);
+  otherMembers.forEach((member) => {
+    legacyGroup.insert(member.sessionId, false); // only one admin for legacy groups
+  });
+
+  [creator, ...otherMembers].forEach((member) => {
+    member.userGroups.setLegacyGroup(legacyGroup);
+  });
+}
+
+export function twoUsersFriends(opts: WithSodium & WithSessionTools) {
+  const alice = createRandomUser(opts);
+  const bob = createRandomUser(opts);
+  makeFriendsAndKnown(alice, bob);
+}
+
+export async function prepareThreeFriendsInSharedGroup() {
+  const sodium = await getSodiumNode();
+  const sessionTools = await loadSessionTools();
+
+  const alice = createRandomUser({ sodium, sessionTools });
+  const bob = createRandomUser({ sodium, sessionTools });
+  const charlie = createRandomUser({ sodium, sessionTools });
+  const users = [alice, bob, charlie];
+
+  try {
+    alice.userProfile.setName('Alice');
+    bob.userProfile.setName('Bob');
+    charlie.userProfile.setName('Charlie');
+
+    makeFriendsAndKnown(alice, bob, charlie);
+
+    makeGroupWithMembers({
+      groupName: 'group test 1',
+      members: [alice, bob, charlie],
+      sodium,
+    });
+
+    const snodesInNetwork = await getAllSnodesFromSeed();
+
+    const randomSnodeFromSeed = sample(snodesInNetwork);
+    await Promise.all(
+      users.map(async (user) => {
+        const randomSnodeOnSwarm = await randomSnodeOnUserSwarm(
+          user.sessionId,
+          randomSnodeFromSeed,
+        );
+        await user.pushChangesToSwarm(randomSnodeOnSwarm);
+      }),
+    );
+    console.warn(`seed of alice: "${users[0].seedPhrase}"`);
+    return users.map((m) => ({ seed: m.seed, sessionId: m.sessionId }));
+  } finally {
+    users.map((user) => user.freeMemory());
+  }
+}