@session-foundation/qa-seeder 0.1.21

package/dist/index.js

@@ -0,0 +1,1043 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  USERNAME: () => USERNAME,
+  buildStateForTest: () => buildStateForTest,
+  usernames: () => usernames
+});
+module.exports = __toCommonJS(index_exports);
+var import_lodash5 = require("lodash");
+
+// src/requests/seedRequest.ts
+var import_lodash = require("lodash");
+var fetchedSnodesFromSeed = {};
+async function getAllSnodesFromSeed(seedNodeUrl) {
+  if (!seedNodeUrl.startsWith("http")) {
+    throw new Error("Invalid seed node URL, must start with http");
+  }
+  if (seedNodeUrl.endsWith("/json_rpc")) {
+    throw new Error("Invalid seed node URL, must NOT finish with /json_rpc");
+  }
+  if (fetchedSnodesFromSeed[seedNodeUrl]?.length) {
+    return fetchedSnodesFromSeed[seedNodeUrl];
+  }
+  const getAll = new GetSnodesFromSeed();
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+  console.info(`Fetching snodes from seed node: "${seedNodeUrl}/json_rpc"`);
+  try {
+    const result = await fetch(`${seedNodeUrl}/json_rpc`, {
+      body: JSON.stringify(getAll.build()),
+      method: "POST"
+    });
+    console.info("snode from list result status:", result.status);
+    const json = await result.json();
+    fetchedSnodesFromSeed[seedNodeUrl] = json.result.service_node_states;
+    return fetchedSnodesFromSeed[seedNodeUrl];
+  } catch (e) {
+    console.warn(e);
+    throw e;
+  }
+}
+async function randomSnodeFromNetwork(seedNodeUrl) {
+  const snodes = await getAllSnodesFromSeed(seedNodeUrl);
+  const snode = (0, import_lodash.sample)(snodes);
+  if (!snode) {
+    throw new Error(`No random snode found on seed node: ${seedNodeUrl}`);
+  }
+  return snode;
+}
+var GetSnodesFromSeed = class {
+  build() {
+    return {
+      jsonrpc: "2.0",
+      id: "0",
+      method: "get_n_service_nodes",
+      params: {
+        active_only: true,
+        limit: 20,
+        fields: {
+          public_ip: true,
+          storage_port: true,
+          pubkey_x25519: true,
+          pubkey_ed25519: true
+        }
+      }
+    };
+  }
+};
+
+// src/sessionTools/index.ts
+var import_libsession_wasm = __toESM(require("@session-foundation/libsession-wasm/"));
+async function loadSessionTools() {
+  const loaded = await (0, import_libsession_wasm.default)();
+  return loaded;
+}
+
+// src/requests/snodeRequests.ts
+var import_lodash2 = require("lodash");
+var SwarmForSubRequest = class {
+  method = "get_swarm";
+  pubkey;
+  constructor(pubkey) {
+    this.pubkey = pubkey;
+  }
+  async build() {
+    return {
+      method: this.method,
+      params: {
+        pubkey: this.pubkey,
+        params: {
+          active_only: true,
+          fields: {
+            public_ip: true,
+            storage_port: true,
+            pubkey_x25519: true,
+            pubkey_ed25519: true
+          }
+        }
+      }
+    };
+  }
+  loggingId() {
+    return `${this.method}`;
+  }
+};
+var StoreUserConfigSubRequest = class {
+  method = "store";
+  namespace;
+  ttlMs;
+  encryptedData;
+  destination;
+  userSigner;
+  constructor(args) {
+    this.namespace = args.namespace;
+    this.ttlMs = args.ttlMs;
+    this.encryptedData = args.encryptedData;
+    this.destination = args.sessionId;
+    this.userSigner = args.userSigner;
+    if ((0, import_lodash2.isEmpty)(this.encryptedData)) {
+      throw new Error("this.encryptedData cannot be empty");
+    }
+    if ((0, import_lodash2.isEmpty)(this.destination)) {
+      throw new Error("this.destination cannot be empty");
+    }
+  }
+  async build() {
+    const encryptedDataBase64 = this.userSigner.sodium.to_base64(
+      this.encryptedData,
+      this.userSigner.sodium.base64_variants.ORIGINAL
+    );
+    const signDetails = await this.userSigner.getSnodeSignatureParams({
+      getNow: () => Date.now(),
+      method: this.method,
+      namespace: this.namespace
+    });
+    if (!signDetails) {
+      throw new Error(
+        `[StoreUserConfigSubRequest] signing returned an empty result`
+      );
+    }
+    const toRet = {
+      method: this.method,
+      params: {
+        namespace: this.namespace,
+        ttl: this.ttlMs,
+        data: encryptedDataBase64,
+        ...signDetails
+      }
+    };
+    return toRet;
+  }
+  loggingId() {
+    return `${this.method}-${this.destination}-${this.namespace}`;
+  }
+  getDestination() {
+    return this.destination;
+  }
+};
+var StoreGroupConfigSubRequest = class {
+  method = "store";
+  namespace;
+  ttlMs;
+  encryptedData;
+  destination;
+  adminGroupSigner;
+  constructor(args) {
+    this.namespace = args.namespace;
+    this.ttlMs = args.ttlMs;
+    this.encryptedData = args.encryptedData;
+    this.destination = args.groupPk;
+    this.adminGroupSigner = args.adminGroupSigner;
+    if ((0, import_lodash2.isEmpty)(this.encryptedData)) {
+      throw new Error("this.encryptedData cannot be empty");
+    }
+    if ((0, import_lodash2.isEmpty)(this.destination)) {
+      throw new Error("this.destination cannot be empty");
+    }
+  }
+  async build() {
+    const encryptedDataBase64 = this.adminGroupSigner.sodium.to_base64(
+      this.encryptedData,
+      this.adminGroupSigner.sodium.base64_variants.ORIGINAL
+    );
+    const signDetails = await this.adminGroupSigner.getSnodeSignatureParams({
+      getNow: () => Date.now(),
+      method: this.method,
+      namespace: this.namespace
+    });
+    if (!signDetails) {
+      throw new Error(
+        `[StoreGroupConfigSubRequest] signing returned an empty result`
+      );
+    }
+    const toRet = {
+      method: this.method,
+      params: {
+        namespace: this.namespace,
+        ttl: this.ttlMs,
+        data: encryptedDataBase64,
+        ...signDetails
+      }
+    };
+    return toRet;
+  }
+  loggingId() {
+    return `${this.method}-${this.destination}-${this.namespace}`;
+  }
+  getDestination() {
+    return this.destination;
+  }
+};
+
+// src/sessionUser.ts
+var import_mnemonic = require("@session-foundation/mnemonic");
+
+// src/signer/userSigner.ts
+var import_sodium = require("@session-foundation/sodium");
+function getVerificationDataForStoreRetrieve(params) {
+  const signatureTimestamp = params.getNow();
+  const verificationString = `${params.method}${params.namespace === 0 ? "" : params.namespace}${signatureTimestamp}`;
+  const verificationData = params.sodium.from_string(verificationString);
+  return {
+    toSign: new Uint8Array(verificationData),
+    signatureTimestamp
+  };
+}
+async function getSnodeSignatureShared(params) {
+  const { signatureTimestamp, toSign } = getVerificationDataForStoreRetrieve(params);
+  const sodium = await (0, import_sodium.getSodium)();
+  const signature = sodium.crypto_sign_detached(toSign, params.privKey);
+  const signatureBase64 = params.sodium.to_base64(
+    signature,
+    params.sodium.base64_variants.ORIGINAL
+  );
+  return {
+    timestamp: signatureTimestamp,
+    signature: signatureBase64
+  };
+}
+var UserSigner = class {
+  ed25519PubKey;
+  ed25519PrivKey;
+  sodium;
+  sessionId;
+  constructor({
+    ed25519PrivKey,
+    ed25519PubKey,
+    sessionId,
+    sodium
+  }) {
+    this.ed25519PubKey = ed25519PubKey;
+    if (this.ed25519PubKey.length !== 64) {
+      console.warn("ed25519PubKey length", ed25519PubKey.length);
+      throw new Error("ed25519PubKey not 64 long");
+    }
+    this.ed25519PrivKey = ed25519PrivKey;
+    if (this.ed25519PrivKey.length !== 64) {
+      console.warn("ed25519PrivKey length", ed25519PrivKey.length);
+      throw new Error("ed25519PrivKey not 64 long");
+    }
+    this.sessionId = sessionId;
+    this.sodium = sodium;
+  }
+  async getSnodeSignatureParams({
+    method,
+    namespace,
+    getNow
+  }) {
+    if (!this.ed25519PrivKey || !this.ed25519PubKey) {
+      const err = `getSnodeSignatureParams "${method}": User has no getUserED25519KeyPairBytes()`;
+      throw new Error(err);
+    }
+    const sigData = await getSnodeSignatureShared({
+      pubKey: this.sessionId,
+      method,
+      namespace,
+      privKey: this.ed25519PrivKey,
+      getNow,
+      sodium: this.sodium
+    });
+    return {
+      ...sigData,
+      pubkey_ed25519: this.ed25519PubKey,
+      pubkey: this.sessionId
+    };
+  }
+};
+
+// src/sessionUser.ts
+function buildUserSigner(user, sodium) {
+  const userSigner = new UserSigner({
+    sessionId: user.sessionId,
+    ed25519PrivKey: user.ed25519Sk,
+    ed25519PubKey: sodium.to_hex(user.ed25519Pk),
+    sodium
+  });
+  return userSigner;
+}
+function generateMnemonic(opts) {
+  const seedSize = 16;
+  const seed = opts.sodium.randombytes_buf(seedSize);
+  const hex = opts.sodium.to_hex(seed);
+  return (0, import_mnemonic.mnEncode)(hex);
+}
+function mnemonicToRawSeed(mnemonic, sodium) {
+  let seedHex = (0, import_mnemonic.mnDecode)(mnemonic);
+  const privKeyHexLength = 32 * 2;
+  if (seedHex.length !== privKeyHexLength) {
+    seedHex = seedHex.concat("0".repeat(32));
+    seedHex = seedHex.substring(0, privKeyHexLength);
+  }
+  const seed = sodium.from_hex(seedHex);
+  return seed;
+}
+function sessionGenerateKeyPair(opts) {
+  const ed25519KeyPair = opts.sodium.crypto_sign_seed_keypair(
+    new Uint8Array(opts.seed)
+  );
+  const x25519PublicKey = opts.sodium.crypto_sign_ed25519_pk_to_curve25519(
+    ed25519KeyPair.publicKey
+  );
+  const origPub = new Uint8Array(x25519PublicKey);
+  const prependedX25519PublicKey = new Uint8Array(33);
+  prependedX25519PublicKey.set(origPub, 1);
+  prependedX25519PublicKey[0] = 5;
+  const x25519SecretKey = opts.sodium.crypto_sign_ed25519_sk_to_curve25519(
+    ed25519KeyPair.privateKey
+  );
+  return {
+    x25519PublicKeyWith05: prependedX25519PublicKey,
+    x25519SecretKey: x25519SecretKey.buffer,
+    ed25519KeyPair
+  };
+}
+var SessionUser = class {
+  sessionId;
+  ed25519Pk;
+  ed25519Sk;
+  seed;
+  seedPhrase;
+  wrappers;
+  userProfile;
+  contacts;
+  userGroups;
+  userSigner;
+  sodium;
+  constructor({ sessionTools, sodium }) {
+    const mnemonic = generateMnemonic({ sodium });
+    const seed = mnemonicToRawSeed(mnemonic, sodium);
+    const userKeys = sessionGenerateKeyPair({ seed, sodium });
+    const userProfile = new sessionTools.UserProfileW(
+      userKeys.ed25519KeyPair.privateKey,
+      void 0
+    );
+    const contacts = new sessionTools.ContactsW(
+      userKeys.ed25519KeyPair.privateKey,
+      void 0
+    );
+    const userGroups = new sessionTools.UserGroupsW(
+      userKeys.ed25519KeyPair.privateKey,
+      void 0
+    );
+    const wrappers = [userProfile, contacts, userGroups];
+    this.sessionId = sodium.to_hex(
+      userKeys.x25519PublicKeyWith05
+    );
+    this.ed25519Pk = userKeys.ed25519KeyPair.publicKey;
+    this.ed25519Sk = userKeys.ed25519KeyPair.privateKey;
+    this.seed = seed;
+    this.seedPhrase = (0, import_mnemonic.mnEncode)(sodium.to_hex(seed).slice(0, 32));
+    this.wrappers = wrappers;
+    this.userProfile = userProfile;
+    this.contacts = contacts;
+    this.userGroups = userGroups;
+    this.sodium = sodium;
+    this.userSigner = buildUserSigner(this, this.sodium);
+  }
+  async pushChangesToSwarm(snode) {
+    const storeRequests = this.wrappers.map(
+      (wrapper) => new StoreUserConfigSubRequest({
+        namespace: wrapper.storageNamespace().value,
+        encryptedData: this.sodium.from_hex(
+          wrapper.makePushHex().get(0)?.toString() ?? ""
+        ),
+        sessionId: this.sessionId,
+        ttlMs: 1e3 * 3600 * 24,
+        // 1 day should be enough for testing and debugging a test?
+        userSigner: this.userSigner
+      })
+    );
+    const storeResult = await Promise.all(
+      storeRequests.map(async (request) => {
+        const builtRequest = await request.build();
+        console.info(
+          "storing to snode",
+          `https://${snode.ip}:${snode.port}/storage_rpc/v1`
+        );
+        const ret = await fetch(
+          `https://${snode.ip}:${snode.port}/storage_rpc/v1`,
+          {
+            body: JSON.stringify(builtRequest),
+            method: "POST"
+          }
+        );
+        return ret.status;
+      })
+    );
+    console.log(`storeStatus for ${this.userProfile.getName()}:`, storeResult);
+  }
+  freeMemory() {
+    this.wrappers.map((wrapper) => wrapper.delete());
+  }
+  toString() {
+    const name = this.userProfile.getName();
+    const sessionId = this.sessionId;
+    const seedPhrase = this.seedPhrase;
+    return `SessionUser: ${JSON.stringify({ name, sessionId, seedPhrase })}`;
+  }
+};
+function createRandomUser(details) {
+  return new SessionUser(details);
+}
+
+// src/signer/groupSigner.ts
+var import_sodium2 = require("@session-foundation/sodium");
+function getVerificationDataForStoreRetrieve2(params) {
+  const signatureTimestamp = params.getNow();
+  const verificationString = `${params.method}${params.namespace === 0 ? "" : params.namespace}${signatureTimestamp}`;
+  const verificationData = params.sodium.from_string(verificationString);
+  return {
+    toSign: new Uint8Array(verificationData),
+    signatureTimestamp
+  };
+}
+async function getSnodeSignatureShared2(params) {
+  const { signatureTimestamp, toSign } = getVerificationDataForStoreRetrieve2(params);
+  const sodium = await (0, import_sodium2.getSodium)();
+  const signature = sodium.crypto_sign_detached(toSign, params.privKey);
+  const signatureBase64 = params.sodium.to_base64(
+    signature,
+    params.sodium.base64_variants.ORIGINAL
+  );
+  return {
+    timestamp: signatureTimestamp,
+    signature: signatureBase64
+  };
+}
+var GroupAdminSigner = class {
+  groupPk;
+  sodium;
+  groupSecretKey;
+  constructor({
+    groupSecretKey,
+    groupPk,
+    sodium
+  }) {
+    this.groupSecretKey = groupSecretKey;
+    if (this.groupSecretKey.length !== 64) {
+      console.warn("groupSecretKey length", groupSecretKey.length);
+      throw new Error("groupSecretKey not 64 long");
+    }
+    this.groupPk = groupPk;
+    this.sodium = sodium;
+  }
+  async getSnodeSignatureParams({
+    method,
+    namespace,
+    getNow
+  }) {
+    const sigData = await getSnodeSignatureShared2({
+      pubKey: this.groupPk,
+      method,
+      namespace,
+      privKey: this.groupSecretKey,
+      getNow,
+      sodium: this.sodium
+    });
+    return {
+      ...sigData,
+      pubkey: this.groupPk
+    };
+  }
+};
+
+// src/sessionGroup.ts
+var import_lodash3 = require("lodash");
+function buildGroupSigner(group, sodium) {
+  if (!group.groupSecretKey) {
+    throw new Error(
+      "only group admin signer (with admin key) is supported currently"
+    );
+  }
+  return new GroupAdminSigner({
+    groupPk: group.groupPk,
+    groupSecretKey: group.groupSecretKey,
+    sodium
+  });
+}
+var SessionGroup = class {
+  groupPk;
+  groupSecretKey;
+  metagroupW;
+  adminGroupSigner;
+  groupName;
+  sodium;
+  constructor({
+    sessionTools,
+    groupName,
+    members,
+    sodium
+  }) {
+    if (!members.length) {
+      throw new Error("Excepted at least one creator/member");
+    }
+    this.groupName = groupName;
+    const [creator, ...otherMembers] = members;
+    if (!creator) {
+      throw new Error("Expected at least the creator");
+    }
+    const newGroup = creator.userGroups.createGroup();
+    newGroup.name = groupName;
+    newGroup.joinedAtSeconds = BigInt(Math.floor(Date.now() / 1e3));
+    this.groupSecretKey = sodium.from_hex(newGroup.adminSecretKey.toString());
+    this.metagroupW = new sessionTools.MetaGroupW(
+      creator.ed25519Sk,
+      sodium.from_hex(newGroup.groupPk.toString().slice(2)).buffer,
+      this.groupSecretKey,
+      void 0
+    );
+    [creator, ...otherMembers].forEach((member) => {
+      if (member.sessionId !== creator.sessionId) {
+        const authDataHex = this.metagroupW.makeSubaccountHex(
+          member.sessionId,
+          true,
+          false
+        );
+        const groupForUser = member.userGroups.getOrConstructGroup(
+          newGroup.groupPk
+        );
+        groupForUser.name = newGroup.name;
+        groupForUser.joinedAtSeconds = newGroup.joinedAtSeconds;
+        groupForUser.invited = false;
+        groupForUser.priority = 0;
+        groupForUser.authData = sodium.from_hex(authDataHex);
+        member.userGroups.setGroup(groupForUser);
+      } else {
+        member.userGroups.setGroup(newGroup);
+      }
+    });
+    this.metagroupW.setNameTruncated(groupName);
+    [creator, ...otherMembers].forEach((u) => {
+      const member = this.metagroupW.membersGetOrConstruct(u.sessionId);
+      if (u.sessionId === creator.sessionId) {
+        member.setPromotionAccepted();
+      } else {
+        member.setInviteAccepted();
+      }
+      member.setNameTruncated(u.userProfile.getName()?.toString() || "");
+      this.metagroupW.membersSet(member);
+    });
+    this.metagroupW.rekeyHex();
+    this.groupPk = newGroup.groupPk.toString();
+    this.sodium = sodium;
+    this.adminGroupSigner = buildGroupSigner(this, this.sodium);
+  }
+  async pushChangesToSwarm(snode) {
+    const pushHex = this.metagroupW.pushHex();
+    const toPush = (0, import_lodash3.compact)([
+      pushHex.keysPush,
+      pushHex.membersPush,
+      pushHex.infosPush
+    ]);
+    const storeRequests = toPush.map((m) => {
+      return new StoreGroupConfigSubRequest({
+        namespace: m.storageNamespace.value,
+        encryptedData: this.sodium.from_hex(m.dataHex.toString()),
+        groupPk: this.groupPk,
+        ttlMs: 1e3 * 3600 * 24,
+        // 1 day should be enough for testing and debugging a test?
+        adminGroupSigner: this.adminGroupSigner
+      });
+    });
+    const storeResult = await Promise.all(
+      storeRequests.map(async (request) => {
+        const builtRequest = await request.build();
+        console.info(
+          "storing to snode",
+          `https://${snode.ip}:${snode.port}/storage_rpc/v1`
+        );
+        const ret = await fetch(
+          `https://${snode.ip}:${snode.port}/storage_rpc/v1`,
+          {
+            body: JSON.stringify(builtRequest),
+            method: "POST"
+          }
+        );
+        return ret.status;
+      })
+    );
+    console.log(`storeStatus for (group) ${this.groupPk}:`, storeResult);
+  }
+  freeMemory() {
+    this.metagroupW.delete();
+  }
+  toString() {
+    const groupName = this.groupName;
+    const groupPk = this.groupPk;
+    const groupSecretKeyHex = this.sodium.to_hex(this.groupSecretKey);
+    return `SessionGroup: ${JSON.stringify({ groupPk, groupName, groupSecretKeyHex })}`;
+  }
+};
+
+// src/index.ts
+var import_basic_types = require("@session-foundation/basic-types");
+var import_sodium3 = require("@session-foundation/sodium");
+
+// src/actions/fetchSwarmOf.ts
+var import_lodash4 = require("lodash");
+var fetchedSwarms = {};
+async function getSwarmOfUser(sessionId, snode) {
+  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 ((0, import_lodash4.isEmpty)(fetchedSwarms[sessionId])) {
+    fetchedSwarms[sessionId] = swarm;
+  }
+  return swarm.snodes;
+}
+async function randomSnodeOnUserSwarm(sessionId, snode) {
+  const userSwarm = fetchedSwarms[sessionId] || await getSwarmOfUser(sessionId, snode);
+  const randomSnodeOnSwarm = (0, import_lodash4.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;
+}
+
+// src/index.ts
+var networks = {
+  mainnet: "https://seed2.getsession.org:4443",
+  testnet: "http://seed2.getsession.org:38157"
+};
+function getSeedNodeUrl(network) {
+  if (network === "mainnet" || network === "testnet") {
+    return networks[network];
+  }
+  return network;
+}
+function makeFriendsAndKnown(users) {
+  if (users.length < 2) {
+    throw new Error("needs at least two users to make them friends");
+  }
+  console.info(
+    `makeFriendsAndKnown: users: [${users.map((m) => m.toString()).join(",\n")}]`
+  );
+  users.forEach((user1) => {
+    users.forEach((user2) => {
+      if (user1.sessionId === user2.sessionId) {
+        console.info(
+          "makeFriendsAndKnown: user1 === user2. Skipping",
+          user1.toString()
+        );
+        return;
+      }
+      console.info("makeFriendsAndKnown: user1", user1.toString());
+      if (user2) {
+        console.info("makeFriendsAndKnown: user2", user2.toString());
+        user1.contacts.setApproved(user2.sessionId, true);
+        user1.contacts.setApprovedMe(user2.sessionId, true);
+        user1.contacts.setName(
+          user2.sessionId,
+          user2.userProfile.getName() || ""
+        );
+        user2.contacts.setApproved(user1.sessionId, true);
+        user2.contacts.setApprovedMe(user1.sessionId, true);
+        user2.contacts.setName(
+          user1.sessionId,
+          user1.userProfile.getName() || ""
+        );
+      }
+    });
+  });
+}
+function makeGroupWithMembers({
+  members,
+  groupName,
+  sessionTools,
+  sodium
+}) {
+  return new SessionGroup({ sessionTools, groupName, members, sodium });
+}
+var PrebuiltStateWithWrappers = class {
+  userWrappers;
+  groupWrapper;
+  constructor(args) {
+    this.userWrappers = args.users;
+    this.groupWrapper = args.group;
+  }
+  async pushChangesToSwarms({
+    seedNodeUrl
+  }) {
+    console.info(`Pushing changes to swarms on network "${seedNodeUrl}"`);
+    const promises = [];
+    if (this.userWrappers && (0, import_lodash5.isArray)(this.userWrappers) && this.userWrappers?.length) {
+      const users = this.userWrappers;
+      const userPromise = pushUsersChangesToSwarm({ seedNodeUrl, users });
+      promises.push(userPromise);
+    }
+    if (this.groupWrapper && this.groupWrapper instanceof SessionGroup) {
+      const randomNetworkSnode = await randomSnodeFromNetwork(seedNodeUrl);
+      const groupWrapper = this.groupWrapper;
+      const swarmSnode = await randomSnodeOnUserSwarm(
+        groupWrapper.groupPk,
+        randomNetworkSnode
+      );
+      const groupPromise = groupWrapper.pushChangesToSwarm(swarmSnode);
+      promises.push(groupPromise);
+    }
+    console.info(`promises`, promises);
+    await Promise.all(promises);
+    console.info(`Pushed changes to swarms on network "${seedNodeUrl}"`);
+  }
+};
+var usernames = ["Alice", "Bob", "Charlie", "Dracula"];
+var USERNAME = {
+  ALICE: "Alice",
+  BOB: "Bob",
+  CHARLIE: "Charlie",
+  DRACULA: "Dracula"
+};
+function assertUserCountIsValid(count) {
+  if (count > usernames.length) {
+    throw new Error(`count should be less than ${usernames.length} currently`);
+  }
+  if (count < 1) {
+    throw new Error("count should be at least 1");
+  }
+}
+function createCountOfUsers({
+  count,
+  sessionTools,
+  sodium
+}) {
+  return Array.from(
+    { length: count },
+    () => createRandomUser({ sodium, sessionTools })
+  );
+}
+function assignNamesToUsers(users) {
+  users.forEach((user, index) => {
+    const name = usernames[index];
+    if (!name) {
+      throw new Error(
+        `assignNamesToUsers: username at index ${index} is empty`
+      );
+    }
+    user.userProfile.setName(name);
+    return user;
+  });
+}
+function createGroupWithMembers({
+  groupName,
+  users,
+  sodium,
+  sessionTools
+}) {
+  if (!groupName) {
+    throw new Error("groupName should be provided");
+  }
+  const group = makeGroupWithMembers({
+    groupName,
+    members: users,
+    sessionTools,
+    sodium
+  });
+  console.log("creatorMetagroupW info:", group.metagroupW.makeInfoDumpHex());
+  console.log(
+    "creatorMetagroupW members:",
+    group.metagroupW.makeMembersDumpHex()
+  );
+  console.log("creatorMetagroupW keys:", group.metagroupW.makeKeysDumpHex());
+  return {
+    group
+  };
+}
+async function pushUsersChangesToSwarm({
+  users,
+  seedNodeUrl
+}) {
+  await Promise.all(
+    users.map(async (user) => {
+      const randomNetworkSnode = await randomSnodeFromNetwork(seedNodeUrl);
+      const swarmSnode = await randomSnodeOnUserSwarm(
+        user.sessionId,
+        randomNetworkSnode
+      );
+      await user.pushChangesToSwarm(swarmSnode);
+    })
+  );
+  console.info(
+    `seed of users:
+	${users.map((u) => `"${u.userProfile.getName()}": "${u.seedPhrase}"`).join("\n	")} `
+  );
+}
+function toStateUsers(users) {
+  return users.map((user, index) => {
+    const userName = user.userProfile.getName()?.toString();
+    if (!userName) {
+      throw new Error(`userName should be defined for user at index: ${index}`);
+    }
+    return {
+      seed: user.seed,
+      seedPhrase: user.seedPhrase,
+      sessionId: user.sessionId,
+      userName
+    };
+  });
+}
+function toStateGroup(group) {
+  if (!group.groupSecretKey || (0, import_lodash5.isEmpty)(group.groupSecretKey)) {
+    throw new Error("groupSecretKey should be defined");
+  }
+  return {
+    groupPk: group.groupPk,
+    groupName: group.groupName,
+    adminSecretKey: group.groupSecretKey
+  };
+}
+function prepareUsers({
+  sessionTools,
+  sodium,
+  usersCount
+}) {
+  const users = createCountOfUsers({
+    count: usersCount,
+    sodium,
+    sessionTools
+  });
+  assignNamesToUsers(users);
+  return users;
+}
+function prepareFriends({
+  friendsCount,
+  sessionTools,
+  sodium
+}) {
+  assertUserCountIsValid(friendsCount);
+  const users = prepareUsers({
+    usersCount: friendsCount,
+    sessionTools,
+    sodium
+  });
+  makeFriendsAndKnown(users);
+  return {
+    stateUsers: toStateUsers(users),
+    usersWrapper: users
+  };
+}
+function prepareFriendsInGroup({
+  friendsCount,
+  groupName,
+  sessionTools,
+  sodium
+}) {
+  if (!groupName) {
+    throw new Error("groupName should be provided");
+  }
+  const { stateUsers, usersWrapper } = prepareFriends({
+    friendsCount,
+    sessionTools,
+    sodium
+  });
+  const { group } = createGroupWithMembers({
+    groupName,
+    users: usersWrapper,
+    sodium,
+    sessionTools
+  });
+  return {
+    stateUsers,
+    usersWrapper,
+    stateGroup: toStateGroup(group),
+    groupWrapper: group
+  };
+}
+async function buildStateForTest(stateToBuild, groupName, network) {
+  const seedNodeUrl = getSeedNodeUrl(network);
+  console.info(
+    `[buildStateForTest] stateToBuild:"${stateToBuild}". seedNodeUrl: "${seedNodeUrl}" (${network})`
+  );
+  const sodium = await (0, import_sodium3.getSodium)();
+  const sessionTools = await loadSessionTools();
+  switch (stateToBuild) {
+    case "none": {
+      return { users: {} };
+    }
+    case "1user": {
+      const users = prepareUsers({ usersCount: 1, sessionTools, sodium });
+      await new PrebuiltStateWithWrappers({
+        users,
+        group: null
+      }).pushChangesToSwarms({ seedNodeUrl });
+      return {
+        users: toStateUsers(users)
+      };
+    }
+    case "2users": {
+      const users = prepareUsers({ usersCount: 2, sessionTools, sodium });
+      await new PrebuiltStateWithWrappers({
+        users,
+        group: null
+      }).pushChangesToSwarms({ seedNodeUrl });
+      return {
+        users: toStateUsers(users)
+      };
+    }
+    case "3users": {
+      const users = prepareUsers({ usersCount: 3, sessionTools, sodium });
+      await new PrebuiltStateWithWrappers({
+        users,
+        group: null
+      }).pushChangesToSwarms({ seedNodeUrl });
+      return {
+        users: toStateUsers(users)
+      };
+    }
+    case "2friends": {
+      const state = prepareFriends({
+        friendsCount: 2,
+        sessionTools,
+        sodium
+      });
+      await new PrebuiltStateWithWrappers({
+        users: state.usersWrapper,
+        group: null
+      }).pushChangesToSwarms({ seedNodeUrl });
+      return {
+        users: state.stateUsers
+      };
+    }
+    case "2friendsInGroup": {
+      if (!groupName) {
+        throw new Error("state 2friendsInGroup needs a groupName");
+      }
+      const state = prepareFriendsInGroup({
+        friendsCount: 2,
+        sessionTools,
+        sodium,
+        groupName
+      });
+      await new PrebuiltStateWithWrappers({
+        users: state.usersWrapper,
+        group: state.groupWrapper
+      }).pushChangesToSwarms({ seedNodeUrl });
+      return {
+        users: state.stateUsers,
+        group: state.stateGroup
+      };
+    }
+    case "3friends": {
+      const state = prepareFriends({
+        friendsCount: 3,
+        sessionTools,
+        sodium
+      });
+      await new PrebuiltStateWithWrappers({
+        users: state.usersWrapper,
+        group: null
+      }).pushChangesToSwarms({ seedNodeUrl });
+      return {
+        users: state.stateUsers
+      };
+    }
+    case "3friendsInGroup": {
+      if (!groupName) {
+        throw new Error("state 3friendsInGroup needs a groupName");
+      }
+      const state = prepareFriendsInGroup({
+        friendsCount: 3,
+        sessionTools,
+        sodium,
+        groupName
+      });
+      await new PrebuiltStateWithWrappers({
+        users: state.usersWrapper,
+        group: state.groupWrapper
+      }).pushChangesToSwarms({ seedNodeUrl });
+      return {
+        users: state.stateUsers,
+        group: state.stateGroup
+      };
+    }
+    default:
+      (0, import_basic_types.assertUnreachable)(
+        stateToBuild,
+        `buildStateForTest of "${stateToBuild}" not implemented`
+      );
+      break;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  USERNAME,
+  buildStateForTest,
+  usernames
+});