@constl/utils-tests 1.7.0 → 2.0.0

package/src/{libp2p.ts → libp2p/config.ts}

@@ -24,89 +24,32 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
-import { Identify, identify } from "@libp2p/identify";
-import { webSockets } from "@libp2p/websockets";
-import { webRTC } from "@libp2p/webrtc";
-import { all } from "@libp2p/websockets/filters";
-import { noise } from "@chainsafe/libp2p-noise";
-import { yamux } from "@chainsafe/libp2p-yamux";
 import {
   gossipsub,
-  GossipSub,
   GossipSubComponents,
+  GossipSub,
 } from "@chainsafe/libp2p-gossipsub";
+import { noise } from "@chainsafe/libp2p-noise";
+import { yamux } from "@chainsafe/libp2p-yamux";
 import { circuitRelayTransport } from "@libp2p/circuit-relay-v2";
-import type { PrivateKey } from "@libp2p/interface";
-import type { Libp2pOptions } from "libp2p";
+import { Identify, identify } from "@libp2p/identify";
+import { webRTC } from "@libp2p/webrtc";
+import { webSockets } from "@libp2p/websockets";
 
-/**
- * A basic Libp2p configuration for Node.js nodes.
- */
-export const DefaultLibp2pOptions: Libp2pOptions<ServicesLibp2pConstlTest> = {
-  addresses: {
-    listen: ["/ip4/0.0.0.0/tcp/0/ws", "/p2p-circuit"],
-  },
-  transports: [
-    webSockets({
-      filter: all,
-    }),
-    webRTC(),
-    circuitRelayTransport(),
-  ],
-  connectionEncrypters: [noise()],
-  streamMuxers: [yamux()],
-  connectionGater: {
-    denyDialMultiaddr: () => false,
-  },
-  services: {
-    identify: identify(),
-    pubsub: gossipsub({ allowPublishToZeroTopicPeers: true }) as (
-      components: GossipSubComponents,
-    ) => GossipSub, // Erreur de type dans @chainsafe/pubsub
-    obtClefPrivée: (components: ComposantesServiceClefPrivée) =>
-      new ServiceClefPrivée(components),
-  },
-};
+import { Libp2pOptions } from "libp2p";
 
-/**
- * A basic Libp2p configuration for browser nodes.
- */
-export const DefaultLibp2pBrowserOptions: Libp2pOptions<ServicesLibp2pConstlTest> =
-  {
-    addresses: {
-      listen: ["/webrtc", "/p2p-circuit"],
-    },
-    transports: [
-      webSockets({
-        filter: all,
-      }),
-      webRTC(),
-      circuitRelayTransport(),
-    ],
-    connectionEncrypters: [noise()],
-    streamMuxers: [yamux()],
-    connectionGater: {
-      denyDialMultiaddr: () => false,
-    },
-    services: {
-      identify: identify(),
-      pubsub: gossipsub({ allowPublishToZeroTopicPeers: true }) as (
-        components: GossipSubComponents,
-      ) => GossipSub, // Erreur de type dans @chainsafe/pubsub,
-      obtClefPrivée: (components: ComposantesServiceClefPrivée) =>
-        new ServiceClefPrivée(components),
-    },
-  };
-
-interface ComposantesServiceClefPrivée {
-  privateKey: PrivateKey;
-}
+import { PrivateKey } from "@libp2p/interface";
 
-export type ServicesLibp2pConstlTest = {
+export type ServicesLibp2pTest = {
   identify: Identify;
   pubsub: GossipSub;
   obtClefPrivée: ServiceClefPrivée;
 };
+
+export interface ComposantesServiceClefPrivée {
+  privateKey: PrivateKey;
+}
+
 export class ServiceClefPrivée {
   privateKey: PrivateKey;
 
@@ -118,3 +61,55 @@ export class ServiceClefPrivée {
     return this.privateKey;
   }
 }
+
+/**
+ * Configuration Libp2p pour Node.js.
+ */
+export const OptionsDéfautLibp2pNode: () => Libp2pOptions<ServicesLibp2pTest> =
+  () => {
+    return {
+      addresses: {
+        listen: ["/ip4/0.0.0.0/tcp/0/ws", "/p2p-circuit"],
+      },
+      transports: [webSockets(), webRTC(), circuitRelayTransport()],
+      connectionEncrypters: [noise()],
+      streamMuxers: [yamux()],
+      connectionGater: {
+        denyDialMultiaddr: () => false,
+      },
+      services: {
+        identify: identify(),
+        pubsub: gossipsub({ allowPublishToZeroTopicPeers: true }) as (
+          components: GossipSubComponents,
+        ) => GossipSub, // Erreur de type dans @chainsafe/pubsub
+        obtClefPrivée: (components: ComposantesServiceClefPrivée) =>
+          new ServiceClefPrivée(components),
+      },
+    };
+  };
+
+/**
+ * Configuration Libp2p pour les navigateurs.
+ */
+export const OptionsDéfautLibp2pNavigateur: () => Libp2pOptions<ServicesLibp2pTest> =
+  () => {
+    return {
+      addresses: {
+        listen: ["/webrtc", "/p2p-circuit"],
+      },
+      transports: [webSockets(), webRTC(), circuitRelayTransport()],
+      connectionEncrypters: [noise()],
+      streamMuxers: [yamux()],
+      connectionGater: {
+        denyDialMultiaddr: () => false,
+      },
+      services: {
+        identify: identify(),
+        pubsub: gossipsub({ allowPublishToZeroTopicPeers: true }) as (
+          components: GossipSubComponents,
+        ) => GossipSub, // Erreur de type dans @chainsafe/pubsub,
+        obtClefPrivée: (components: ComposantesServiceClefPrivée) =>
+          new ServiceClefPrivée(components),
+      },
+    };
+  };

package/src/libp2p/index.ts

@@ -0,0 +1,9 @@
+export {
+  ServicesLibp2pTest,
+  ComposantesServiceClefPrivée,
+  ServiceClefPrivée,
+  OptionsDéfautLibp2pNode,
+  OptionsDéfautLibp2pNavigateur,
+} from "./config.js";
+export { créerLibp2psTest } from "./libp2p.js";
+export { connecterPairs, toutesConnectées } from "./utils.js";

package/src/libp2p/libp2p.ts

@@ -0,0 +1,41 @@
+import { Libp2p } from "@libp2p/interface";
+import { createLibp2p } from "libp2p";
+import {
+  OptionsDéfautLibp2pNavigateur,
+  OptionsDéfautLibp2pNode,
+  ServicesLibp2pTest,
+} from "./config.js";
+import { isBrowser } from "wherearewe";
+import { connecterPairs } from "./utils.js";
+import { obtenirAdresseRelai } from "../relai/index.js";
+
+export const créerLibp2psTest = async ({
+  n,
+  adresseRelai,
+}: {
+  n: number;
+  adresseRelai?: string;
+}): Promise<{
+  libp2ps: Libp2p<ServicesLibp2pTest>[];
+  fermer: () => Promise<void>;
+}> => {
+  adresseRelai = adresseRelai ?? obtenirAdresseRelai();
+
+  const libp2ps: Libp2p<ServicesLibp2pTest>[] = [];
+  for (const _ of Array(n).keys()) {
+    const libp2p = await createLibp2p(
+      isBrowser ? OptionsDéfautLibp2pNavigateur() : OptionsDéfautLibp2pNode(),
+    );
+
+    for (const l of libp2ps) {
+      await connecterPairs(libp2p, l, { adresseRelai });
+    }
+    libp2ps.push(libp2p);
+  }
+
+  const fermer = async () => {
+    await Promise.all(libp2ps.map((l) => l.stop()));
+  };
+
+  return { libp2ps, fermer };
+};

package/src/libp2p/utils.ts

@@ -0,0 +1,59 @@
+import { Libp2p } from "@libp2p/interface";
+import { WebRTC } from "@multiformats/multiaddr-matcher";
+import { multiaddr, Multiaddr } from "@multiformats/multiaddr";
+import { isBrowser, isElectronRenderer } from "wherearewe";
+import { ServicesLibp2pTest } from "./config.js";
+
+const filtreParDéfaut = () => true;
+
+type OptionsConnectionPairs = {
+  adresseRelai: string;
+  filtre?: (ma: Multiaddr) => boolean;
+};
+export const connecterPairs = async <
+  T extends Libp2p = Libp2p<ServicesLibp2pTest>,
+>(
+  libp2p1: T,
+  libp2p2: T,
+  options: OptionsConnectionPairs,
+) => {
+  const filtre = options.filtre ?? filtreParDéfaut;
+
+  if (isBrowser || isElectronRenderer) {
+    await libp2p1.dial(multiaddr(options.adresseRelai));
+
+    const adresse1 = await new Promise<Multiaddr>((resolve) => {
+      const testConnecté = () => {
+        const adresse = libp2p1
+          .getMultiaddrs()
+          .filter((ma) => WebRTC.matches(ma) && filtre(ma))
+          .pop();
+        if (adresse != null) {
+          clearInterval(interval);
+          resolve(adresse);
+        }
+      };
+      const interval = setInterval(testConnecté, 100);
+      testConnecté();
+    });
+    await libp2p2.dial(adresse1);
+  } else {
+    await libp2p2.peerStore.save(libp2p1.peerId, {
+      multiaddrs: libp2p1.getMultiaddrs().filter(filtre),
+    });
+    await libp2p2.dial(libp2p1.peerId);
+  }
+};
+
+export const toutesConnectées = async (
+  libp2ps: Libp2p<ServicesLibp2pTest>[],
+  options: OptionsConnectionPairs,
+) => {
+  const connectées: Libp2p<ServicesLibp2pTest>[] = [];
+  for (const lib of libp2ps) {
+    for (const autre of connectées) {
+      await connecterPairs(lib, autre, options);
+    }
+    connectées.push(lib);
+  }
+};

package/src/orbite.ts

@@ -1,241 +1,56 @@
-/*
-Certaines parties de ce fichier proviennent d'OrbitDB et de @orbitdb/quickstart
-
-MIT License
-
-Copyright (c) 2019 Haja Networks Oy
-Copyright (c) 2024 OrbitDB Community
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-import type { Helia } from "helia";
-import type {
-  Identity,
-  OrbitDB,
-  Database,
-  IdentitiesType,
-} from "@orbitdb/core";
-import {
-  type TypedKeyValue,
-  type TypedFeed,
-  type TypedSet,
-  type TypedOrderedKeyValue,
-} from "@constl/bohr-db";
-import { once } from "events";
-
-import { dossierTempo } from "@/dossiers.js";
-import { connecterPairs } from "@/sfip.js";
-import { isNode, isElectronMain } from "wherearewe";
-
-import { createHelia } from "helia";
-import { Libp2p, createLibp2p } from "libp2p";
-import { createOrbitDB } from "@orbitdb/core";
-import { LevelBlockstore } from "blockstore-level";
-import { bitswap } from "@helia/block-brokers";
-import {
-  DefaultLibp2pOptions,
-  DefaultLibp2pBrowserOptions,
-  type ServicesLibp2pConstlTest,
-} from "./libp2p.js";
-import type { ServiceMap } from "@libp2p/interface";
-
-const isBrowser = () => typeof window !== "undefined";
-
-const startOrbitDB = async ({
-  id,
-  identity,
-  identities,
-  directory,
-}: {
-  id?: string;
-  identity?: Identity;
-  identities?: IdentitiesType;
-  directory?: string;
-} = {}) => {
-  const options = isBrowser()
-    ? DefaultLibp2pBrowserOptions
-    : DefaultLibp2pOptions;
-  const libp2p = await createLibp2p({ ...options });
-  directory = directory || ".";
-  const blockstore = new LevelBlockstore(`${directory}/ipfs/blocs`);
-  const ipfs = await createHelia({
-    libp2p,
-    blockstore,
-    blockBrokers: [bitswap()],
-  });
-  const orbitdb = await createOrbitDB({
-    ipfs,
-    id,
-    identity,
-    identities,
-    directory,
-  });
-  return orbitdb;
-};
-
-const stopOrbitDB = async (orbitdb: OrbitDB<ServicesLibp2pConstlTest>) => {
-  await orbitdb.stop();
-  await orbitdb.ipfs.stop();
-  // @ts-expect-error Je ne sais pas pourquoi
-  await orbitdb.ipfs.blockstore.unwrap().unwrap().child.db.close();
-};
-
-export const créerOrbiteTest = async ({
-  n = 1,
+import { OrbitDB, createOrbitDB } from "@orbitdb/core";
+import { dossierTempo } from "./dossiers.js";
+import { ServicesLibp2pTest } from "./libp2p/index.js";
+import { créerHéliasTest } from "./hélia.js";
+import { join } from "path";
+import { sousDossier } from "./utils.js";
+import { obtenirAdresseRelai } from "./relai/utils.js";
+
+export const créerOrbitesTest = async ({
+  n,
+  dossier,
+  adresseRelai,
 }: {
   n: number;
+  dossier?: string;
+  adresseRelai?: string;
 }): Promise<{
-  orbites: OrbitDB<ServicesLibp2pConstlTest>[];
-  fOublier: () => Promise<void>;
+  orbites: OrbitDB<ServicesLibp2pTest>[];
+  fermer: () => Promise<void>;
 }> => {
-  const sfips: Helia<Libp2p<ServicesLibp2pConstlTest>>[] = [];
-  const orbites: OrbitDB<ServicesLibp2pConstlTest>[] = [];
-
-  const {
-    dossier: racineDossierOrbite,
-    fEffacer: fEffacerRacineDossierOrbite,
-  } = await dossierTempo();
-
-  const _générer = async (i: number): Promise<void> => {
-    const racineDossier = `${racineDossierOrbite}/${i}`;
-    const orbite = await startOrbitDB({
-      directory: `${racineDossier}/orbite`,
-    });
-    for (const ip of sfips) {
-      await connecterPairs(orbite.ipfs, ip);
-    }
-    sfips.push(orbite.ipfs);
-
-    orbites.push(orbite);
-  };
-
-  await Promise.all([...Array(n).keys()].map((i) => _générer(i)));
-
-  const fOublier = async () => {
-    for (const o of orbites) await stopOrbitDB(o);
-
-    try {
-      fEffacerRacineDossierOrbite();
-    } catch (e) {
-      // Sur Windows, parfois les fichiers de Hélia sont encore en utilisation
-      if ((isNode || isElectronMain) && process.platform === "win32") {
-        console.log("On ignore ça sur Windows\n", e);
-        return;
-      } else {
-        throw e;
-      }
-    }
-  };
-  return { orbites, fOublier };
-};
-
-export const attendreSync = async (
-  bd: Awaited<ReturnType<typeof Database>>,
-): Promise<void> => {
-  await once(bd.events, "update");
-};
+  adresseRelai = adresseRelai ?? obtenirAdresseRelai();
 
-export type ContrôleurConstellation = {
-  type: string;
-  address: string;
-  adresseBdAccès: string;
-  write: string;
-  estAutorisé: (id: string) => Promise<boolean>;
-  grant: (rôle: "MODÉRATEUR" | "MEMBRE", id: string) => Promise<void>;
-  revoke: (_rôle: "MODÉRATEUR" | "MEMBRE", _id: string) => Promise<void>;
-  bd: Awaited<ReturnType<typeof Database>>;
-};
+  let effacerDossier: () => void = () => {};
+  if (!dossier) {
+    ({ dossier, effacer: effacerDossier } = await dossierTempo());
+  }
 
-const attendreInvité = (
-  accès: ContrôleurConstellation,
-  idInvité: string,
-): Promise<void> =>
-  new Promise<void>((résoudre) => {
-    const testAutorisé = async () => {
-      const autorisé = await accès.estAutorisé(idInvité);
-      if (autorisé) {
-        résoudre();
-      } else {
-        setTimeout(testAutorisé, 100);
-      }
-    };
-    testAutorisé();
+  const orbites: OrbitDB<ServicesLibp2pTest>[] = [];
+  const { hélias, fermer: fermerHélias } = await créerHéliasTest({
+    n,
+    dossier,
+    adresseRelai,
   });
 
-export const peutÉcrire = async <T extends ServiceMap = ServiceMap>(
-  bd:
-    | TypedKeyValue<{ [clef: string]: number }>
-    | TypedOrderedKeyValue<{ [clef: string]: number }>
-    | TypedSet<string>
-    | TypedFeed<string>,
-  attendre?: OrbitDB<T>,
-): Promise<boolean> => {
-  if (attendre) {
-    await attendreInvité(
-      bd.access as unknown as ContrôleurConstellation,
-      attendre.identity.id,
+  let i = 0;
+  for (const hélia of hélias) {
+    orbites.push(
+      await createOrbitDB({
+        ipfs: hélia,
+        directory: join(sousDossier({ dossier, i }), "orbite"),
+      }),
     );
+    i++;
   }
 
-  try {
-    if (bd.type === "keyvalue" || bd.type === "ordered-keyvalue") {
-      const bdKV = bd as TypedKeyValue<{ [clef: string]: number }>;
-
-      // Important d'avoir une clef unique pour éviter l'interférence entre les tests
-      const CLEF = "test" + Math.random().toString();
-      const VAL = 123;
-
-      await bdKV.set(CLEF, VAL);
-      const val = await bdKV.get(CLEF);
-
-      await bdKV.del(CLEF);
-      return val === VAL;
-    } else if (bd.type === "feed") {
-      const VAL = "test";
-
-      await (bd as TypedFeed<string>).add(VAL);
-      const éléments = await (bd as TypedFeed<string>).all();
-
-      const autorisé = éléments.length === 1 && éléments[0].value === VAL;
-      if (éléments.length === 1) {
-        await (bd as TypedFeed<string>).remove(éléments[0].hash);
-      }
-      return autorisé;
-    } else if (bd.type === "set") {
-      const VAL = "test";
-
-      await bd.add(VAL);
-      const éléments = await bd.all();
-
-      const autorisé = éléments.size === 1 && éléments.has(VAL);
-      await bd.del(VAL);
+  const fermer = async () => {
+    await Promise.all(orbites.map((o) => o.stop()));
+    await fermerHélias();
+    effacerDossier();
+  };
 
-      return autorisé;
-    } else {
-      // @ts-expect-error bd.type n'a plus d'options
-      throw new Error(`Type de BD ${bd.type} non supporté par ce test.`);
-    }
-  } catch (e) {
-    if (e.toString().includes("is not allowed to write to the log")) {
-      return false;
-    }
-    throw e;
-  }
+  return {
+    orbites,
+    fermer,
+  };
 };

package/src/{scripts/relai.ts → relai/bin.ts}

@@ -29,31 +29,26 @@ import { createLibp2p } from "libp2p";
 import { noise } from "@chainsafe/libp2p-noise";
 import { circuitRelayServer } from "@libp2p/circuit-relay-v2";
 import { webSockets } from "@libp2p/websockets";
-import * as filters from "@libp2p/websockets/filters";
 import { identify } from "@libp2p/identify";
 import { keys } from "@libp2p/crypto";
 import { fromString as uint8ArrayFromString } from "uint8arrays/from-string";
 import { FaultTolerance } from "@libp2p/interface";
+import { CLEF_PRIVÉE_RELAI, PORT_DÉFAUT_RELAI } from "./consts.js";
 
-// output of: console.log(server.peerId.privateKey.toString('hex'))
-const privateKeyString =
-  "08011240821cb6bc3d4547fcccb513e82e4d718089f8a166b23ffcd4a436754b6b0774cf07447d1693cd10ce11ef950d7517bad6e9472b41a927cd17fc3fb23f8c70cd99";
-// L'identité de pair qui correspond à la clef privée ci-dessus
-// const relayId = '12D3KooWAJjbRkp8FPF5MKgMU53aUTxWkqvDrs4zc1VMbwRwfsbE'
+// produit par: console.log(server.peerId.privateKey.toString('hex'))
+const privateKeyString = process.env.CLEF_PRIVÉE_RELAI || CLEF_PRIVÉE_RELAI;
 
-const encoded = uint8ArrayFromString(privateKeyString, "hex");
-const privateKey = keys.privateKeyFromProtobuf(encoded);
+const chiffrée = uint8ArrayFromString(privateKeyString, "hex");
+const clefPrivée = keys.privateKeyFromProtobuf(chiffrée);
 
 const relai = await createLibp2p({
-  privateKey,
+  privateKey: clefPrivée,
   addresses: {
-    listen: ["/ip4/0.0.0.0/tcp/54321/ws"],
+    listen: [
+      `/ip4/0.0.0.0/tcp/${process.env.PORT_DÉFAUT_RELAI || PORT_DÉFAUT_RELAI}/ws`,
+    ],
   },
-  transports: [
-    webSockets({
-      filter: filters.all,
-    }),
-  ],
+  transports: [webSockets()],
   transportManager: {
     faultTolerance: FaultTolerance.NO_FATAL,
   },
@@ -88,4 +83,4 @@ console.log(
   "p2p addr: ",
   relai.getMultiaddrs().map((ma) => ma.toString()),
 );
-// generates a deterministic address: /ip4/127.0.0.1/tcp/54321/ws/p2p/12D3KooWAJjbRkp8FPF5MKgMU53aUTxWkqvDrs4zc1VMbwRwfsbE
+// génère une adresse prédéterminée : /ip4/127.0.0.1/tcp/54321/ws/p2p/12D3KooWAJjbRkp8FPF5MKgMU53aUTxWkqvDrs4zc1VMbwRwfsbE

package/src/relai/consts.ts

@@ -0,0 +1,5 @@
+export const PORT_DÉFAUT_RELAI = 54321;
+export const CLEF_PRIVÉE_RELAI =
+  "08011240821cb6bc3d4547fcccb513e82e4d718089f8a166b23ffcd4a436754b6b0774cf07447d1693cd10ce11ef950d7517bad6e9472b41a927cd17fc3fb23f8c70cd99";
+export const ID_DÉFAUT_RELAI =
+  "12D3KooWAJjbRkp8FPF5MKgMU53aUTxWkqvDrs4zc1VMbwRwfsbE";

package/src/relai/index.ts

@@ -0,0 +1,3 @@
+export { ID_DÉFAUT_RELAI, PORT_DÉFAUT_RELAI } from "./consts.js";
+export { obtenirAdresseRelai } from "./utils.js";
+export { lancerRelai, obtenirFichierRelai } from "./relai.js";

package/src/relai/relai.ts

@@ -0,0 +1,40 @@
+export const obtenirFichierRelai = async (): Promise<string> => {
+  const path = await import("path");
+  const url = await import("url");
+  const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+
+  const fichierRelai = path.join(__dirname, "./bin.js");
+  return fichierRelai;
+};
+
+export const lancerRelai = async ({
+  portDéfautRelai,
+  clefPrivéeRelai,
+}: {
+  portDéfautRelai?: string;
+  clefPrivéeRelai?: string;
+} = {}) => {
+  const { execa } = await import("execa");
+
+  const fichierRelai = await obtenirFichierRelai();
+
+  const relai = execa({
+    env: {
+      ...process.env,
+      PORT_DÉFAUT_RELAI: portDéfautRelai,
+      CLEF_PRIVÉE_RELAI: clefPrivéeRelai,
+    },
+  })`node ${fichierRelai} &`;
+
+  relai.catch((e) => {
+    // Ignorer l'erreur causée par la termination du processus par notre code
+    if (e.signal !== "SIGTERM") throw new Error(e);
+  });
+
+  relai.stdout.on("data", (x) => {
+    const texte = new TextDecoder().decode(x);
+    console.log(texte);
+  });
+
+  return () => relai.kill();
+};

package/src/relai/utils.ts

@@ -0,0 +1,14 @@
+import { ID_DÉFAUT_RELAI, PORT_DÉFAUT_RELAI } from "./consts.js";
+
+export const obtenirAdresseRelai = (
+  {
+    portRelai,
+    idRelai,
+  }: {
+    portRelai: number;
+    idRelai: string;
+  } = {
+    portRelai: PORT_DÉFAUT_RELAI,
+    idRelai: ID_DÉFAUT_RELAI,
+  },
+) => `/ip4/127.0.0.1/tcp/${portRelai}/ws/p2p/${idRelai}`;

package/src/utils.ts

@@ -0,0 +1,5 @@
+import { join } from "path";
+
+export const sousDossier = ({ dossier, i }: { dossier: string; i: number }) => {
+  return join(dossier, i.toString());
+};

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = "1.7.0";
+export const version = "2.0.0";