@leofcoin/peernet 1.1.65 → 1.1.67

package/exports/browser/browser-2c73e2ef.js

@@ -0,0 +1,25 @@
+var browser$1 = {};
+
+browser$1.MediaStream = window.MediaStream;
+browser$1.MediaStreamTrack = window.MediaStreamTrack;
+browser$1.RTCDataChannel = window.RTCDataChannel;
+browser$1.RTCDataChannelEvent = window.RTCDataChannelEvent;
+browser$1.RTCDtlsTransport = window.RTCDtlsTransport;
+browser$1.RTCIceCandidate = window.RTCIceCandidate;
+browser$1.RTCIceTransport = window.RTCIceTransport;
+browser$1.RTCPeerConnection = window.RTCPeerConnection;
+browser$1.RTCPeerConnectionIceEvent = window.RTCPeerConnectionIceEvent;
+browser$1.RTCRtpReceiver = window.RTCRtpReceiver;
+browser$1.RTCRtpSender = window.RTCRtpSender;
+browser$1.RTCRtpTransceiver = window.RTCRtpTransceiver;
+browser$1.RTCSctpTransport = window.RTCSctpTransport;
+browser$1.RTCSessionDescription = window.RTCSessionDescription;
+browser$1.getUserMedia = window.getUserMedia;
+browser$1.mediaDevices = navigator.mediaDevices;
+
+var browser = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	default: browser$1
+});
+
+export { browser as b };

package/exports/browser/{index-ddb4220d.js → index-1d597e6b.js}

@@ -1,4 +1,4 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './peernet-4149fb9c.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './peernet-55ce42c7.js';
 import './value-4e80eeeb.js';
 
 /**

package/exports/browser/{messages-c24213c9.js → messages-67e5efa0.js}

@@ -1,4 +1,4 @@
-import { F as FormatInterface } from './peernet-4149fb9c.js';
+import { F as FormatInterface } from './peernet-55ce42c7.js';
 import './value-4e80eeeb.js';
 
 var proto$b = {

package/exports/browser/{peernet-4149fb9c.js → peernet-55ce42c7.js}

@@ -27088,7 +27088,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-ddb4220d.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-1d597e6b.js');
             const { identity, accounts } = await importee.default(password, this.network);
             await globalThis.accountStore.put('public', JSON.stringify({ walletId: identity.walletId }));
             await globalThis.walletStore.put('version', String(1));
@@ -27280,7 +27280,7 @@ class Peernet {
         this.root = options.root;
         const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
         // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-c24213c9.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-67e5efa0.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -27371,12 +27371,228 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-d602421d.js');
+        const importee = class Client {
+    #peerId;
+    #connections = {};
+    #stars = {};
+    id;
+    networkVersion;
+    starsConfig;
+    socketClient;
+    messageSize = 262144;
+    version;
+    #messagesToHandle = {};
+    get peerId() {
+        return this.#peerId;
+    }
+    get connections() {
+        return { ...this.#connections };
+    }
+    get peers() {
+        return Object.entries(this.#connections);
+    }
+    getPeer(peerId) {
+        return this.#connections[peerId];
+    }
+    constructor(peerId, networkVersion = 'peach', version, stars = ['wss://peach.leofcoin.org']) {
+        this.#peerId = peerId;
+        this.networkVersion = networkVersion;
+        this.version = version;
+        this._init(stars);
+    }
+    async _init(stars = []) {
+        this.starsConfig = stars;
+        // reconnectJob()
+        if (!globalThis.RTCPeerConnection)
+            globalThis.wrtc = (await import('./browser-2c73e2ef.js').then(function (n) { return n.b; })).default;
+        for (const star of stars) {
+            try {
+                const client = new SocketRequestClient(star, this.networkVersion);
+                this.#stars[star] = await client.init();
+                this.setupStarListeners(this.#stars[star]);
+                this.#stars[star].send({
+                    url: 'join',
+                    params: { version: this.version, peerId: this.peerId }
+                });
+            }
+            catch (e) {
+                if (stars.indexOf(star) === stars.length - 1 && !this.socketClient)
+                    throw new Error(`No star available to connect`);
+            }
+        }
+        if (globalThis.navigator) {
+            globalThis.addEventListener('beforeunload', async () => this.close());
+        }
+        else {
+            process.on('SIGINT', async () => {
+                process.stdin.resume();
+                await this.close();
+                process.exit();
+            });
+        }
+    }
+    setupStarListeners(star) {
+        star.pubsub.subscribe('peer:joined', (id) => this.#peerJoined(id, star));
+        star.pubsub.subscribe('peer:left', (id) => this.#peerLeft(id, star));
+        star.pubsub.subscribe('star:joined', this.#starJoined);
+        star.pubsub.subscribe('star:left', this.#starLeft);
+        star.pubsub.subscribe('signal', (message) => this.#inComingSignal(message, star));
+    }
+    #starJoined = (id) => {
+        if (this.#stars[id]) {
+            this.#stars[id].close(0);
+            delete this.#stars[id];
+        }
+        console.log(`star ${id} joined`);
+    };
+    #starLeft = async (id) => {
+        if (this.#stars[id]) {
+            this.#stars[id].close(0);
+            delete this.#stars[id];
+        }
+        if (Object.keys(this.#stars).length === 0) {
+            for (const star of this.starsConfig) {
+                try {
+                    const socketClient = await new SocketRequestClient(star, this.networkVersion).init();
+                    if (!socketClient?.client?.OPEN)
+                        return;
+                    this.#stars[star] = socketClient;
+                    this.#stars[star].send({
+                        url: 'join',
+                        params: { peerId: this.peerId, version: this.version }
+                    });
+                    this.setupStarListeners(socketClient);
+                }
+                catch (e) {
+                    if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1)
+                        throw new Error(`No star available to connect`);
+                }
+            }
+        }
+        globalThis.debug(`star ${id} left`);
+    };
+    #peerLeft(peer, star) {
+        const id = peer.peerId || peer;
+        if (this.#connections[id]) {
+            this.#connections[id].destroy();
+            delete this.#connections[id];
+        }
+        globalThis.debug(`peer ${id} left`);
+    }
+    #createRTCPeerConnection = (peerId, star, version, initiator = false) => {
+        const peer = new Peer({
+            initiator: initiator,
+            from: this.peerId,
+            to: peerId,
+            version
+        });
+        peer.on('signal', (signal) => this.#peerSignal(peer, signal, star));
+        peer.on('connect', () => this.#peerConnect(peer));
+        peer.on('close', () => this.#peerClose(peer));
+        peer.on('data', (data) => this.#peerData(peer, data));
+        peer.on('error', (error) => this.#peerError(peer, error));
+        this.#connections[peerId] = peer;
+    };
+    #peerJoined = async ({ peerId, version }, star) => {
+        // check if peer rejoined before the previous connection closed
+        if (this.#connections[peerId]) {
+            if (this.#connections[peerId].connected)
+                this.#connections[peerId].destroy();
+            delete this.#connections[peerId];
+        }
+        // RTCPeerConnection
+        this.#createRTCPeerConnection(peerId, star, version, true);
+        globalThis.debug(`peer ${peerId} joined`);
+    };
+    #inComingSignal = async ({ from, signal, channelName, version }, star) => {
+        if (version !== this.version) {
+            console.warn(`${from} joined using the wrong version.\nexpected: ${this.version} but got:${version}`);
+            return;
+        }
+        let peer = this.#connections[from];
+        if (!peer) {
+            this.#createRTCPeerConnection(from, star, version);
+            peer = this.#connections[from];
+        }
+        if (String(peer.channelName) !== String(channelName))
+            console.warn(`channelNames don't match: got ${peer.channelName}, expected: ${channelName}`);
+        peer.signal(signal);
+    };
+    #peerSignal = (peer, signal, star) => {
+        let client = this.#stars[star];
+        if (!client)
+            client = this.#stars[Object.keys(this.#stars)[0]];
+        client.send({
+            url: 'signal',
+            params: {
+                from: this.peerId,
+                to: peer.peerId,
+                channelName: peer.channelName,
+                version: this.version,
+                signal
+            }
+        });
+    };
+    #peerClose = (peer) => {
+        if (this.#connections[peer.peerId]) {
+            this.#connections[peer.peerId].destroy();
+            delete this.#connections[peer.peerId];
+        }
+        globalThis.debug(`closed ${peer.peerId}'s connection`);
+    };
+    #peerConnect = (peer) => {
+        globalThis.debug(`${peer.peerId} connected`);
+        globalThis.pubsub.publish('peer:connected', peer.peerId);
+    };
+    #noticeMessage = (message, id) => {
+        if (globalThis.pubsub.subscribers[id]) {
+            globalThis.pubsub.publish(id, new Uint8Array(message));
+        }
+        else {
+            globalThis.pubsub.publish('peer:data', new Uint8Array(message));
+        }
+    };
+    #peerData = (peer, data) => {
+        const { id, size, chunk } = JSON.parse(new TextDecoder().decode(data));
+        peer.bw.down += size;
+        if (size <= MAX_MESSAGE_SIZE) {
+            this.#noticeMessage(chunk, id);
+        }
+        else {
+            if (!this.#messagesToHandle[id])
+                this.#messagesToHandle[id] = [];
+            this.#messagesToHandle[id] = [
+                ...this.#messagesToHandle[id],
+                ...Object.values(chunk)
+            ];
+            if (this.#messagesToHandle[id].length === Number(size)) {
+                this.#noticeMessage(this.#messagesToHandle[id], id);
+                delete this.#messagesToHandle[id];
+            }
+        }
+    };
+    #peerError = (peer, error) => {
+        console.warn(`Connection error: ${error.message}`);
+        peer.destroy();
+    };
+    async close() {
+        for (const star in this.#stars) {
+            if (this.#stars[star].connectionState() === 'open')
+                await this.#stars[star].send({ url: 'leave', params: this.peerId });
+        }
+        const promises = [
+            Object.values(this.#connections).map((connection) => connection.destroy()),
+            Object.values(this.#stars).map((connection) => connection.close(0))
+        ];
+        await Promise.allSettled(promises);
+    }
+};
         /**
          * @access public
          * @type {PeernetClient}
          */
-        this.client = new importee.default(this.id, this.networkVersion, this.stars);
+        console.log(this.stars);
+        this.client = new importee.default(this.id, this.networkVersion, this.version, this.stars);
         this.#started = true;
         this.#starting = false;
     }

package/exports/browser/peernet.js

@@ -1,2 +1,2 @@
-export { P as default } from './peernet-4149fb9c.js';
+export { P as default } from './peernet-55ce42c7.js';
 import './value-4e80eeeb.js';

package/exports/peernet.js

@@ -632,12 +632,13 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('@netpeer/p2pt-swarm');
+        const importee = await import('@netpeer/swarm/client');
         /**
          * @access public
          * @type {PeernetClient}
          */
-        this.client = new importee.default(this.id, this.networkVersion, this.stars);
+        console.log(this.stars);
+        this.client = new importee.default(this.id, this.networkVersion, this.version, this.stars);
         this.#started = true;
         this.#starting = false;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.1.65",
+  "version": "1.1.67",
   "description": "",
   "main": "src/peernet.js",
   "exports": {
@@ -33,9 +33,11 @@
     "@leofcoin/generate-account": "^2.0.0",
     "@leofcoin/identity-utils": "^1.0.2",
     "@leofcoin/multi-wallet": "^3.1.4",
+    "@leofcoin/p2pt": "^1.7.6",
     "@leofcoin/peernet-swarm": "^1.1.0",
     "@leofcoin/storage": "^3.0.0",
-    "@netpeer/p2pt-swarm": "^1.3.2",
+    "@netpeer/p2pt-swarm": "^1.3.5",
+    "@netpeer/swarm": "^0.7.2",
     "@types/node": "^18.11.18",
     "@vandeurenglenn/base32": "^1.1.0",
     "@vandeurenglenn/base58": "^1.1.0",
@@ -47,7 +49,7 @@
     "multi-signature": "^1.3.1",
     "qr-scanner": "^1.4.2",
     "qrcode": "^1.5.1",
-    "socket-request-client": "^1.5.0",
+    "socket-request-client": "^2.0.6",
     "socket-request-server": "^1.5.0"
   },
   "devDependencies": {

package/rollup.config.js

@@ -1,76 +1,70 @@
-import resolve, { nodeResolve } from "@rollup/plugin-node-resolve";
-import commonjs from "@rollup/plugin-commonjs";
-import json from "@rollup/plugin-json";
-import wasm from "@rollup/plugin-wasm";
-import rimraf from "rimraf";
-import typescript from "@rollup/plugin-typescript";
-import modify from "rollup-plugin-modify";
+import resolve, { nodeResolve } from '@rollup/plugin-node-resolve'
+import commonjs from '@rollup/plugin-commonjs'
+import json from '@rollup/plugin-json'
+import wasm from '@rollup/plugin-wasm'
+import rimraf from 'rimraf'
+import typescript from '@rollup/plugin-typescript'
+import modify from 'rollup-plugin-modify'
 
-rimraf.sync("./exports/**");
+rimraf.sync('./exports/**')
 
 export default [
   {
-    input: [
-      "./src/peernet.ts",
-      "./node_modules/@leofcoin/storage/exports/browser-store.js",
-    ],
+    input: ['./src/peernet.ts', './node_modules/@leofcoin/storage/exports/browser-store.js'],
     output: {
-      format: "es",
-      dir: "./exports/browser",
+      format: 'es',
+      dir: './exports/browser'
     },
     plugins: [
       json(),
       wasm(),
       modify({
-        "@netpeer/p2pt-swarm": "@netpeer/p2pt-swarm/browser",
+        "await import('@netpeer/swarm/client')": (await import('@netpeer/swarm/browser')).default.toString()
       }),
       resolve({
         browser: true,
         preferBuiltins: false,
-        mainFields: ["browser", "module", "main"],
+        mainFields: ['browser', 'module', 'main']
       }),
       commonjs({
-        mainFields: ["browser", "module", "main"],
+        mainFields: ['browser', 'module', 'main']
       }),
 
-      typescript({ compilerOptions: { outDir: "./exports/browser" } }),
+      typescript({ compilerOptions: { outDir: './exports/browser' } })
     ],
-    external: ["./prompts/password.js"],
+    external: ['./prompts/password.js']
   },
   {
-    input: [
-      "./src/peernet.ts",
-      "./node_modules/@leofcoin/storage/exports/store.js",
-    ],
+    input: ['./src/peernet.ts', './node_modules/@leofcoin/storage/exports/store.js'],
     output: {
-      format: "es",
-      dir: "./exports",
+      format: 'es',
+      dir: './exports'
     },
     plugins: [
       modify({
-        "@netpeer/p2pt-swarm": "@netpeer/p2pt-swarm",
+        '@netpeer/swarm/client': '@netpeer/swarm/client'
       }),
       typescript({
         compilerOptions: {
-          outDir: "./exports",
-          declarationDir: "./exports/types",
-        },
-      }),
+          outDir: './exports',
+          declarationDir: './exports/types'
+        }
+      })
     ],
-    external: ["./prompts/password.js"],
+    external: ['./prompts/password.js']
   },
   {
-    input: ["./src/prompts/password/browser.js"],
+    input: ['./src/prompts/password/browser.js'],
     output: {
-      format: "es",
-      file: "./exports/browser/src/prompts/password.js",
-    },
+      format: 'es',
+      file: './exports/browser/src/prompts/password.js'
+    }
   },
   {
-    input: ["./src/prompts/password/node.js"],
+    input: ['./src/prompts/password/node.js'],
     output: {
-      format: "es",
-      file: "./exports/src/prompts/password.js",
-    },
-  },
-];
+      format: 'es',
+      file: './exports/src/prompts/password.js'
+    }
+  }
+]

package/src/peernet.ts

@@ -311,12 +311,14 @@ export default class Peernet {
     if (this.#starting || this.#started) return
 
     this.#starting = true
-    const importee = await import('@netpeer/p2pt-swarm')
+    const importee = await import('@netpeer/swarm/client')
     /**
      * @access public
      * @type {PeernetClient}
      */
-    this.client = new importee.default(this.id, this.networkVersion, this.stars)
+    console.log(this.stars)
+
+    this.client = new importee.default(this.id, this.networkVersion, this.version, this.stars)
     this.#started = true
     this.#starting = false
   }

package/test.js

@@ -1,64 +1,62 @@
 import Client from './exports/peernet.js'
 
-
-
-  const client = await new Client({
-    network: 'leofcoin:peach', networkVersion: 'peach', stars: ['wss://peach.leofcoin.org']
-  })
-  console.log(pubsub.subscribers);
-  pubsub.subscribe('peer:discovered', (data) => {
-    // console.log(data);
-    console.log(`discovered: ${Object.keys(peernet.client.discovered).length}`);
-    console.log(Object.keys(peernet.client.discovered));
-  })
-  pubsub.subscribe('peer:connected', (data) => {
-    // console.log(data);
-    console.log(`connections: ${peernet.connections.length}`);
-  })
-  pubsub.subscribe('peer:left', (data) => {
-    console.log(`connections: ${peernet.connections.length}`);
-    console.log(`discovered: ${Object.keys(peernet.client.discovered).length}`);
-    // console.log(data);
-  })
-
-  // peernet.addFolder([{
-  //   path: 'assets/asset.png',
-  //   content: Buffer.from('png')
-  // }, {
-  //   path: 'index.html',
-  //   content: Buffer.from('html')
-  // }]).then(hash => peernet.ls(hash).then(paths => peernet.cat(paths[0].hash).then(content => console.log(content))))
-
-  // pubsub.subscribe('peer:connected', async peer => {
-  //   chainStore.put('localBlock', '00000')
-  //   const request = await new globalThis.peernet.protos['peernet-request']({
-  //           request:'lastBlock'
-  //         })
-  //   const to = peer.id
-  //   await peernet.data.put('hello', 'hi')
-  //   console.log({request});
-  //   const node = await peernet.prepareMessage(request)
-  //   console.log({node});
-  //   let response = await peer.request(node.encoded)
-  //   console.log({response});
-  //   const keys = Object.keys(response)
-  //   const uint8Array = new Uint8Array(keys.length)
-  //   for (const key of keys) {
-  //     uint8Array[Number(key)] = response[key]
-  //   }
-  //   // const proto = await new globalThis.peernet.protos['peernet-message'](uint8Array)
-  //   // console.log(proto.decoded.data);
-  //   response = await new globalThis.peernet.protos['peernet-response'](uint8Array)
-  //   console.log({response});
-
-  //   const block = new TextDecoder().decode(response.decoded.response)
-  //   console.log(block);
-  //   const task = () => setTimeout(() => {
-  //     console.log(peernet.connections[0]?.connected);
-  //     console.log(pubsub.subscribers);
-  //     task()
-  //   }, 5000);
-    // task()
-  // })
-
-
+const client = await new Client({
+  network: 'leofcoin:peach',
+  networkVersion: 'peach',
+  stars: ['wss://star.leofcoin.org']
+})
+console.log(pubsub.subscribers)
+pubsub.subscribe('peer:discovered', (data) => {
+  // console.log(data);
+  console.log(`discovered: ${Object.keys(peernet.client.discovered).length}`)
+  console.log(Object.keys(peernet.client.discovered))
+})
+pubsub.subscribe('peer:connected', (data) => {
+  // console.log(data);
+  console.log(`connections: ${peernet.connections.length}`)
+})
+pubsub.subscribe('peer:left', (data) => {
+  console.log(`connections: ${peernet.connections.length}`)
+  console.log(`discovered: ${Object.keys(peernet.client.discovered).length}`)
+  // console.log(data);
+})
+
+// peernet.addFolder([{
+//   path: 'assets/asset.png',
+//   content: Buffer.from('png')
+// }, {
+//   path: 'index.html',
+//   content: Buffer.from('html')
+// }]).then(hash => peernet.ls(hash).then(paths => peernet.cat(paths[0].hash).then(content => console.log(content))))
+
+// pubsub.subscribe('peer:connected', async peer => {
+//   chainStore.put('localBlock', '00000')
+//   const request = await new globalThis.peernet.protos['peernet-request']({
+//           request:'lastBlock'
+//         })
+//   const to = peer.id
+//   await peernet.data.put('hello', 'hi')
+//   console.log({request});
+//   const node = await peernet.prepareMessage(request)
+//   console.log({node});
+//   let response = await peer.request(node.encoded)
+//   console.log({response});
+//   const keys = Object.keys(response)
+//   const uint8Array = new Uint8Array(keys.length)
+//   for (const key of keys) {
+//     uint8Array[Number(key)] = response[key]
+//   }
+//   // const proto = await new globalThis.peernet.protos['peernet-message'](uint8Array)
+//   // console.log(proto.decoded.data);
+//   response = await new globalThis.peernet.protos['peernet-response'](uint8Array)
+//   console.log({response});
+
+//   const block = new TextDecoder().decode(response.decoded.response)
+//   console.log(block);
+//   const task = () => setTimeout(() => {
+//     console.log(peernet.connections[0]?.connected);
+//     console.log(pubsub.subscribers);
+//     task()
+//   }, 5000);
+// task()
+// })

package/test2.js

@@ -1,7 +1,11 @@
-const Client = require('./dist/commonjs/peernet.js');
-
-(async () => {
-  const client = await new Client({root: '.peernet/test2', network: 'leofcoin:peach', networkVersion: 'peach'})
+import Client from './exports/peernet.js'
+;(async () => {
+  const client = await new Client({
+    root: '.peernet/test2',
+    network: 'peach',
+    networkVersion: 'peach',
+    stars: [['wss://star.leofcoin.org']]
+  })
   const job = () => client.publish('socket-data', 'hello')
   setTimeout(async () => {
     job()