@leofcoin/peernet 0.17.1 → 0.18.1

package/exports/browser/client-1c52a169.js

@@ -0,0 +1,645 @@
+import { L as LittlePubSub } from './peernet-3b3933a5.js';
+import './value-40634404.js';
+
+var clientApi = _pubsub => {
+
+  const subscribe = (topic, cb) => {
+    _pubsub.subscribe(topic, cb);
+  };
+
+  const unsubscribe = (topic, cb) => {
+    _pubsub.unsubscribe(topic, cb);
+  };
+
+  const publish = (topic, value) => {
+    _pubsub.publish(topic, value);
+  };
+
+  const connectionState = (state) => {
+    switch (state) {
+      case 0:
+        return 'connecting'
+      case 1:
+        return 'open'
+      case 2:
+        return 'closing'
+      case 3:
+        return 'closed'
+    }
+  };
+  /**
+   * @param {string} type
+   * @param {string} name
+   * @param {object} params
+   */
+  const request = (client, request) => {
+    return new Promise((resolve, reject) => {
+
+      const state = connectionState(client.readyState);
+      if (state !== 'open') return reject(`coudn't send request to ${client.id}, no open connection found.`)
+
+      request.id = Math.random().toString(36).slice(-12);
+      const handler = result => {
+        if (result && result.error) return reject(result.error)
+        resolve({result, id: request.id, handler});
+        unsubscribe(request.id, handler);
+      };
+      subscribe(request.id, handler);
+      send(client, request);
+    });
+  };
+
+  const send = async (client, request) => {
+    return client.send(JSON.stringify(request))
+  };
+
+  const pubsub = client => {
+    return {
+      publish: (topic = 'pubsub', value) => {
+        return send(client, {url: 'pubsub', params: { topic, value }})
+      },
+      subscribe: (topic = 'pubsub', cb) => {
+        subscribe(topic, cb);
+        return send(client, {url: 'pubsub', params: { topic, subscribe: true }})
+      },
+      unsubscribe: (topic = 'pubsub', cb) => {
+        unsubscribe(topic, cb);
+        return send(client, {url: 'pubsub', params: { topic, unsubscribe: true }})
+      },
+      subscribers: _pubsub.subscribers
+    }
+  };
+
+  const server = (client) => {
+    return {
+      uptime: async () => {
+        try {
+          const { result, id, handler } = await request(client, {url: 'uptime'});
+          unsubscribe(id, handler);
+          return result
+        } catch (e) {
+          throw e
+        }
+      },
+      ping: async () => {
+        try {
+          const now = new Date().getTime();
+          const { result, id, handler } = await request(client, {url: 'ping'});
+          unsubscribe(id, handler);
+          return (Number(result) - now)
+        } catch (e) {
+          throw e
+        }
+      }
+    }
+  };
+
+  const peernet = (client) => {
+    return {
+      join: async (params) => {
+        try {
+          params.join = true;
+          const requested = { url: 'peernet', params };
+          const { result, id, handler } = await request(client, requested);
+          unsubscribe(id, handler);
+          return result
+        } catch (e) {
+          throw e
+        }
+      },
+      leave: async (params) => {
+        try {
+          params.join = false;
+          const requested = { url: 'peernet', params };
+          const { result, id, handler } = await request(client, requested);
+          unsubscribe(id, handler);
+          return result
+        } catch (e) {
+          throw e
+        }
+      }
+    }
+  };
+
+  return { send, request, pubsub, server, subscribe, unsubscribe, publish, peernet, connectionState }
+};
+
+if (!globalThis.PubSub) globalThis.PubSub = LittlePubSub;
+if (!globalThis.pubsub) globalThis.pubsub = new LittlePubSub({verbose: false});
+
+const socketRequestClient = (url, protocols = 'echo-protocol', options = { retry: true, timeout: 10_000, times: 10 }) => {
+  let { retry, timeout, times } = options;
+  if (retry === undefined) retry = true;
+  if (timeout === undefined) timeout = 10_000;  
+  if (times === undefined) times = 10;
+
+  const api = clientApi(pubsub);
+
+  let tries = 0;
+
+  const onerror = error => {
+    if (pubsub.subscribers['error']) {
+      pubsub.publish('error', error);
+    } else {
+      console.error(error);
+    }
+  };
+
+  const onmessage = message => {
+    const {value, url, status, id} = JSON.parse(message.data.toString());
+    const publisher = id ? id : url;
+    if (status === 200) {
+      pubsub.publish(publisher, value);
+    } else {
+      pubsub.publish(publisher, {error: value});
+    }
+  };
+
+  const clientConnection = client => {
+    const startTime = new Date().getTime();
+    return {
+      client,
+      request: async req => {
+        const { result, id, handler } = await api.request(client, req);
+        pubsub.unsubscribe(id, handler);
+        return result
+      },
+      send: req => api.send(client, req),
+      subscribe: api.subscribe,
+      unsubscribe: api.unsubscribe,
+      subscribers: api.subscribers,
+      publish: api.publish,
+      pubsub: api.pubsub(client),
+      uptime: () => {
+        const now = new Date().getTime();
+        return (now - startTime)
+      },
+      peernet: api.peernet(client),
+      server: api.server(client),
+      connectionState: () => api.connectionState(client.readyState),
+      close: exit => {
+        // client.onclose = message => {
+        //   if (exit) process.exit()
+        // }
+        client.close();
+      }
+    }
+  };
+
+  return new Promise(async (resolve, reject) => {
+    const init = async () => {
+      let ws;
+      if (typeof process === 'object' && !globalThis.WebSocket) {
+        ws = (await import('./browser-2f0b2829.js').then(function (n) { return n.b; })).default;
+        ws = ws.w3cwebsocket;
+      } else {
+        ws = WebSocket;
+      }
+      const client = new ws(url, protocols);
+
+      client.onmessage = onmessage;
+      client.onerror = onerror;
+      
+      client.onopen = () => {
+        tries = 0;
+        resolve(clientConnection(client));
+      };
+      client.onclose = message => {
+        tries++;
+        if (!retry) return reject(options)
+        if (tries > times) {
+          console.log(`${protocols} Client Closed`);
+          console.error(`could not connect to - ${url}/`);
+          return resolve(clientConnection(client))
+        }
+        if (message.code === 1006) {
+          console.log(`Retrying in ${timeout} ms`);
+          setTimeout(() => {
+            return init();
+          }, timeout);
+        }
+      };
+    };
+    return init();
+  });
+};
+
+class Peer {
+    #connection;
+    #connected = false;
+    #messageQue = [];
+    #chunksQue = {};
+    #channel;
+    #peerId;
+    #channelName;
+    #chunkSize = 16 * 1024; // 16384
+    #queRunning = false;
+    #MAX_BUFFERED_AMOUNT = 16 * 1024 * 1024;
+    get connection() {
+        return this.#connection;
+    }
+    get connected() {
+        return this.#connected;
+    }
+    get readyState() {
+        return this.#channel?.readyState;
+    }
+    /**
+     * @params {Object} options
+     * @params {string} options.channelName - this peerid : otherpeer id
+     */
+    constructor(options = {}) {
+        this._in = this._in.bind(this);
+        this.offerOptions = options.offerOptions;
+        this.initiator = options.initiator;
+        this.streams = options.streams;
+        this.socketClient = options.socketClient;
+        this.id = options.id;
+        this.to = options.to;
+        this.bw = {
+            up: 0,
+            down: 0
+        };
+        this.#channelName = options.channelName;
+        this.#peerId = options.peerId;
+        this.options = options;
+        return this.#init();
+    }
+    get peerId() {
+        return this.#peerId;
+    }
+    set socketClient(value) {
+        // this.socketClient?.pubsub.unsubscribe('signal', this._in)
+        this._socketClient = value;
+        this._socketClient.pubsub.subscribe('signal', this._in);
+    }
+    get socketClient() {
+        return this._socketClient;
+    }
+    splitMessage(message) {
+        const chunks = [];
+        message = pako.deflate(message);
+        const size = message.byteLength || message.length;
+        let offset = 0;
+        return new Promise((resolve, reject) => {
+            const splitMessage = () => {
+                const chunk = message.slice(offset, offset + this.#chunkSize > size ? size : offset + this.#chunkSize);
+                offset += this.#chunkSize;
+                chunks.push(chunk);
+                if (offset < size)
+                    return splitMessage();
+                else
+                    resolve({ chunks, size });
+            };
+            splitMessage();
+        });
+    }
+    async #runQue() {
+        this.#queRunning = true;
+        if (this.#messageQue.length > 0 && this.#channel?.bufferedAmount + this.#messageQue[0]?.length < this.#MAX_BUFFERED_AMOUNT) {
+            const message = this.#messageQue.shift();
+            switch (this.#channel?.readyState) {
+                case 'open':
+                    await this.#channel.send(message);
+                    if (this.#messageQue.length > 0)
+                        return this.#runQue();
+                    else
+                        this.#queRunning = false;
+                    break;
+                case 'closed':
+                case 'closing':
+                    this.#messageQue = [];
+                    this.#queRunning = false;
+                    debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
+                    break;
+                case undefined:
+                    this.#messageQue = [];
+                    this.#queRunning = false;
+                    debug(`trying to send before a channel is created`);
+                    break;
+            }
+        }
+        else {
+            return setTimeout(() => this.#runQue(), 50);
+        }
+    }
+    #trySend({ size, id, chunks }) {
+        let offset = 0;
+        for (const chunk of chunks) {
+            const start = offset;
+            const end = offset + chunk.length;
+            const message = new TextEncoder().encode(JSON.stringify({ size, id, chunk, start, end }));
+            this.#messageQue.push(message);
+        }
+        if (!this.queRunning)
+            return this.#runQue();
+    }
+    async send(message, id) {
+        const { chunks, size } = await this.splitMessage(message);
+        return this.#trySend({ size, id, chunks });
+    }
+    request(data) {
+        return new Promise((resolve, reject) => {
+            const id = Math.random().toString(36).slice(-12);
+            const _onData = message => {
+                if (message.id === id) {
+                    resolve(message.data);
+                    pubsub.unsubscribe(`peer:data`, _onData);
+                }
+            };
+            pubsub.subscribe(`peer:data`, _onData);
+            // cleanup subscriptions
+            // setTimeout(() => {
+            //   pubsub.unsubscribe(`peer:data-request-${id}`, _onData)
+            // }, 5000);
+            this.send(data, id);
+        });
+    }
+    async #init() {
+        try {
+            if (!globalThis.pako) {
+                const importee = await import('./pako.esm-aa674ebf.js');
+                globalThis.pako = importee.default;
+            }
+            const iceServers = [{
+                    urls: 'stun:stun.l.google.com:19302' // Google's public STUN server
+                }, {
+                    urls: "stun:openrelay.metered.ca:80",
+                }, {
+                    urls: "turn:openrelay.metered.ca:443",
+                    username: "openrelayproject",
+                    credential: "openrelayproject",
+                }, {
+                    urls: "turn:openrelay.metered.ca:443?transport=tcp",
+                    username: "openrelayproject",
+                    credential: "openrelayproject",
+                }];
+            this.#connection = new wrtc.RTCPeerConnection({ iceServers });
+            this.#connection.onicecandidate = ({ candidate }) => {
+                if (candidate) {
+                    this.address = candidate.address;
+                    this.port = candidate.port;
+                    this.protocol = candidate.protocol;
+                    this.ipFamily = this.address.includes('::') ? 'ipv6' : 'ipv4';
+                    this._sendMessage({ candidate });
+                }
+            };
+            // if (this.initiator) this.#connection.onnegotiationneeded = () => {
+            // console.log('create offer');
+            this.#connection.ondatachannel = (message) => {
+                message.channel.onopen = () => {
+                    this.#connected = true;
+                    //  debug(`peer:connected ${this}`)
+                    pubsub.publish('peer:connected', this);
+                };
+                message.channel.onclose = () => this.close.bind(this);
+                message.channel.onmessage = (message) => {
+                    this._handleMessage(this.id, message);
+                };
+                this.#channel = message.channel;
+            };
+            if (this.initiator) {
+                this.#channel = this.#connection.createDataChannel('messageChannel');
+                this.#channel.onopen = () => {
+                    this.#connected = true;
+                    pubsub.publish('peer:connected', this);
+                    // this.#channel.send('hi')
+                };
+                this.#channel.onclose = () => this.close.bind(this);
+                this.#channel.onmessage = (message) => {
+                    this._handleMessage(this.peerId, message);
+                };
+                const offer = await this.#connection.createOffer();
+                await this.#connection.setLocalDescription(offer);
+                this._sendMessage({ 'sdp': this.#connection.localDescription });
+            }
+        }
+        catch (e) {
+            console.log(e);
+        }
+        return this;
+    }
+    _handleMessage(peerId, message) {
+        //  debug(`incoming message from ${peerId}`)
+        message = JSON.parse(new TextDecoder().decode(message.data));
+        // allow sharding (multiple peers share data)
+        pubsub.publish('peernet:shard', message);
+        const { id } = message;
+        if (!this.#chunksQue[id])
+            this.#chunksQue[id] = [];
+        if (message.size > this.#chunksQue[id].length || message.size === this.#chunksQue[id].length) {
+            for (const value of Object.values(message.chunk)) {
+                this.#chunksQue[id].push(value);
+            }
+        }
+        if (message.size === this.#chunksQue[id].length) {
+            let data = new Uint8Array(Object.values(this.#chunksQue[id]));
+            delete this.#chunksQue[id];
+            data = pako.inflate(data);
+            pubsub.publish('peer:data', { id, data, from: this.peerId });
+        }
+        this.bw.down += message.byteLength || message.length;
+    }
+    _sendMessage(message) {
+        this.socketClient.send({ url: 'signal', params: {
+                to: this.to,
+                from: this.id,
+                channelName: this.options.channelName,
+                ...message
+            } });
+    }
+    async _in(message, data) {
+        // message = JSON.parse(message);
+        if (!this.#connection || message.to !== this.id || message.from !== this.#peerId)
+            return;
+        // if (data.videocall) return this._startStream(true, false); // start video and audio stream
+        // if (data.call) return this._startStream(true, true); // start audio stream
+        if (this.#connection?.signalinState === 'stable' && this.#connection?.remoteDescription !== null && this.#connection?.localDescription !== null)
+            return;
+        if (message.candidate) {
+            // debug(`incoming candidate ${this.#channelName}`)
+            // debug(message.candidate.candidate)
+            this.remoteAddress = message.candidate.address;
+            this.remotePort = message.candidate.port;
+            this.remoteProtocol = message.candidate.protocol;
+            this.remoteIpFamily = this.remoteAddress?.includes('::') ? 'ipv6' : 'ipv4';
+            return this.#connection.addIceCandidate(new wrtc.RTCIceCandidate(message.candidate));
+        }
+        try {
+            if (message.sdp) {
+                if (message.sdp.type === 'offer') {
+                    // debug(`incoming offer ${this.#channelName}`)
+                    await this.#connection.setRemoteDescription(new wrtc.RTCSessionDescription(message.sdp));
+                    const answer = await this.#connection.createAnswer();
+                    await this.#connection.setLocalDescription(answer);
+                    this._sendMessage({ 'sdp': this.#connection.localDescription });
+                }
+                if (message.sdp.type === 'answer') {
+                    // debug(`incoming answer ${this.#channelName}`)
+                    await this.#connection.setRemoteDescription(new wrtc.RTCSessionDescription(message.sdp));
+                }
+            }
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+    close() {
+        //  debug(`closing ${this.peerId}`)
+        this.#connected = false;
+        this.#channel?.close();
+        this.#connection?.close();
+        this.socketClient.pubsub.unsubscribe('signal', this._in);
+    }
+}
+
+class Client {
+    #peerConnection;
+    #connections = {};
+    #stars = {};
+    id;
+    networkVersion;
+    starsConfig;
+    socketClient;
+    get connections() {
+        return { ...this.#connections };
+    }
+    get peers() {
+        return Object.entries(this.#connections);
+    }
+    constructor(id, networkVersion = 'peach', stars = ['wss://peach.leofcoin.org']) {
+        this.id = id || Math.random().toString(36).slice(-12);
+        this.peerJoined = this.peerJoined.bind(this);
+        this.peerLeft = this.peerLeft.bind(this);
+        this.starLeft = this.starLeft.bind(this);
+        this.starJoined = this.starJoined.bind(this);
+        this.networkVersion = networkVersion;
+        this._init(stars);
+    }
+    async _init(stars = []) {
+        this.starsConfig = stars;
+        // reconnectJob()
+        if (!globalThis.RTCPeerConnection)
+            globalThis.wrtc = (await import('./browser-3c1d0477.js').then(function (n) { return n.b; })).default;
+        else
+            globalThis.wrtc = {
+                RTCPeerConnection,
+                RTCSessionDescription,
+                RTCIceCandidate
+            };
+        for (const star of stars) {
+            try {
+                this.socketClient = await socketRequestClient(star, this.networkVersion);
+                const id = await this.socketClient.request({ url: 'id', params: { from: this.id } });
+                this.socketClient.peerId = id;
+                this.#stars[id] = this.socketClient;
+            }
+            catch (e) {
+                if (stars.indexOf(star) === stars.length - 1 && !this.socketClient)
+                    throw new Error(`No star available to connect`);
+            }
+        }
+        const peers = await this.socketClient.peernet.join({ id: this.id });
+        for (const id of peers) {
+            if (id !== this.id && !this.#connections[id])
+                this.#connections[id] = await new Peer({ channelName: `${id}:${this.id}`, socketClient: this.socketClient, id: this.id, to: id, peerId: id });
+        }
+        this.setupListeners();
+    }
+    setupListeners() {
+        this.socketClient.subscribe('peer:joined', this.peerJoined);
+        this.socketClient.subscribe('peer:left', this.peerLeft);
+        this.socketClient.subscribe('star:left', this.starLeft);
+    }
+    starJoined(id) {
+        if (this.#stars[id]) {
+            this.#stars[id].close();
+            delete this.#stars[id];
+        }
+        console.log(`star ${id} joined`);
+    }
+    async starLeft(id) {
+        if (this.#stars[id]) {
+            this.#stars[id].close();
+            delete this.#stars[id];
+        }
+        if (this.socketClient?.peerId === id) {
+            this.socketClient.unsubscribe('peer:joined', this.peerJoined);
+            this.socketClient.unsubscribe('peer:left', this.peerLeft);
+            this.socketClient.unsubscribe('star:left', this.starLeft);
+            this.socketClient.close();
+            this.socketClient = undefined;
+            for (const star of this.starsConfig) {
+                try {
+                    this.socketClient = await socketRequestClient(star, this.networkVersion);
+                    if (!this.socketClient?.client?._connection.connected)
+                        return;
+                    const id = await this.socketClient.request({ url: 'id', params: { from: this.id } });
+                    this.#stars[id] = this.socketClient;
+                    this.socketClient.peerId = id;
+                    const peers = await this.socketClient.peernet.join({ id: this.id });
+                    this.setupListeners();
+                    for (const id of peers) {
+                        if (id !== this.id) {
+                            // close connection
+                            if (this.#connections[id]) {
+                                if (this.#connections[id].connected)
+                                    await this.#connections[id].close();
+                                delete this.#connections[id];
+                            }
+                            // reconnect
+                            if (id !== this.id)
+                                this.#connections[id] = await new Peer({ channelName: `${id}:${this.id}`, socketClient: this.socketClient, id: this.id, to: id, peerId: id });
+                        }
+                    }
+                }
+                catch (e) {
+                    console.log(e);
+                    if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1 && !this.socketClient)
+                        throw new Error(`No star available to connect`);
+                }
+            }
+        }
+        globalThis.debug(`star ${id} left`);
+    }
+    peerLeft(peer) {
+        const id = peer.peerId || peer;
+        if (this.#connections[id]) {
+            this.#connections[id].close();
+            delete this.#connections[id];
+        }
+        globalThis.debug(`peer ${id} left`);
+    }
+    async peerJoined(peer, signal) {
+        const id = peer.peerId || peer;
+        if (this.#connections[id]) {
+            if (this.#connections[id].connected)
+                this.#connections[id].close();
+            delete this.#connections[id];
+        }
+        // RTCPeerConnection
+        this.#connections[id] = await new Peer({ initiator: true, channelName: `${this.id}:${id}`, socketClient: this.socketClient, id: this.id, to: id, peerId: id });
+        globalThis.debug(`peer ${id} joined`);
+    }
+    removePeer(peer) {
+        const id = peer.peerId || peer;
+        if (this.#connections[id]) {
+            this.#connections[id].connected && this.#connections[id].close();
+            delete this.#connections[id];
+        }
+        globalThis.debug(`peer ${id} removed`);
+    }
+    async close() {
+        this.socketClient.unsubscribe('peer:joined', this.peerJoined);
+        this.socketClient.unsubscribe('peer:left', this.peerLeft);
+        this.socketClient.unsubscribe('star:left', this.starLeft);
+        const promises = [
+            Object.values(this.#connections).map(connection => connection.close()),
+            Object.values(this.#stars).map(connection => connection.close()),
+            this.socketClient.close()
+        ];
+        return Promise.allSettled(promises);
+    }
+}
+
+export { Client as default };

package/exports/browser/dht/dht.d.ts

@@ -0,0 +1,30 @@
+export default class DhtEarth {
+    providerMap: Map<any, any>;
+    /**
+     * @param {Object} address
+     * @return {Object} {latitude: lat, longitude: lon}
+     */
+    getCoordinates(address: any): any;
+    /**
+     * @param {Object} peer
+     * @param {Object} provider
+     * @return {Object} {provider, distance}
+     */
+    getDistance(peer: any, provider: any): any;
+    /**
+     * @param {Array} providers
+     * @return {Object} closestPeer
+     */
+    closestPeer(providers: any[]): any;
+    /**
+     * @param {String} hash
+     * @return {Array} providers
+     */
+    providersFor(hash: string): any[];
+    /**
+     * @param {String} address
+     * @param {String} hash
+     * @return {Array} providers
+     */
+    addProvider(address: string, hash: string): any[];
+}

package/exports/browser/discovery/peer-discovery.d.ts

@@ -0,0 +1,7 @@
+export default class PeerDiscovery {
+    constructor(id: any);
+    id: any;
+    _getPeerId(id: any): any;
+    discover(peer: any): Promise<any>;
+    discoverHandler(message: any, peer: any): Promise<void>;
+}

package/exports/browser/errors/errors.d.ts

@@ -0,0 +1,3 @@
+export function encapsulatedError(): Error;
+export function dhtError(proto: any): Error;
+export function nothingFoundError(hash: any): Error;

package/exports/browser/handlers/data.d.ts

@@ -0,0 +1,2 @@
+export default dataHandler;
+declare function dataHandler(message: any): Promise<void>;