https://github.com/shivamycodee/dchat-app-git

https://github.com/shivamycodee/dchat-app-git

Last synced: 12 months ago
JSON representation

• Host: GitHub
• URL: https://github.com/shivamycodee/dchat-app-git
• Owner: Shivamycodee
• Created: 2023-02-20T08:30:00.000Z (over 3 years ago)
• Default Branch: main
• Last Pushed: 2023-04-11T06:19:52.000Z (about 3 years ago)
• Last Synced: 2025-02-13T06:51:34.152Z (over 1 year ago)
• Language: JavaScript
• Homepage: https://dchat-app-git.vercel.app
• Size: 5.68 MB
• Stars: 0
• Watchers: 1
• Forks: 0
• Open Issues: 1
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

          
import React,{useState,useEffect} from 'react'

import Card from 'react-bootstrap/Card'

import Badge from 'react-bootstrap/Badge'

import libp2p,{ createLibp2p } from "libp2p";

import { webRTCStar } from "@libp2p/webrtc-star";

import {noise} from "@chainsafe/libp2p-noise"

import {mplex} from '@libp2p/mplex'

import { Multiaddr } from "multiaddr";

import { webSockets } from "@libp2p/websockets";

import { kadDHT } from "@libp2p/kad-dht";

import { floodsub } from "@libp2p/floodsub";

import { bootstrap } from "@libp2p/bootstrap";

import { peerIdFromString, PeerId } from "@libp2p/peer-id";

import { fromString as uint8ArrayFromString } from "uint8arrays/from-string";

import { toString as uint8ArrayToString } from "uint8arrays/to-string";

 function chatCore() {

 

  const [nodE,setNodE] = useState();

  const [peers,setPeers] = useState()

  const [peerId,setPeerId] = useState();

  const [msg,setMsg] =  useState();

  

  const start = async()=>{

    

    try{

      const wrtcStar = webRTCStar();

     const node = await createLibp2p({

        addresses: {

          // Add the signaling server address, along with our PeerId to our multiaddrs list

          // libp2p will automatically attempt to dial to the signaling server so that it can

          // receive inbound connections from other peers

          listen: [

            "/dns4/wrtc-star1.par.dwebops.pub/tcp/443/wss/p2p-webrtc-star",

            // "/dns4/wrtc-star2.sjc.dwebops.pub/tcp/443/wss/p2p-webrtc-star",

          ],

        },

        transports: [webSockets(), wrtcStar.transport],

        connectionEncryption: [noise()],

        streamMuxers: [mplex()],

        peerDiscovery: [

          wrtcStar.discovery,

          bootstrap({

            list: [

              "/dnsaddr/bootstrap.libp2p.io/p2p/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN",

              "/dnsaddr/bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb",

              "/dnsaddr/bootstrap.libp2p.io/p2p/QmZa1sAxajnQjVM8WjWXoMbmPd7NsWhfKsPkErzpm9wGkp",

              "/dnsaddr/bootstrap.libp2p.io/p2p/QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa",

              "/dnsaddr/bootstrap.libp2p.io/p2p/QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt",

            ],

          }),

        ],

        dht: kadDHT(),

        // we add the Pubsub module we want

        pubsub: floodsub(),

      });

      node.start();

      setNodE(node);

        

    const madd  = node.getMultiaddrs()

    alert(madd);

    setPeerId(madd.toString().slice(65, -1));

      // Listen for new peers

      node.addEventListener("peer:discovery", (evt) => {

        const peer = evt.detail;

        console.log(`Found peer ${peer.id.toString()}`)

        // console.warn("evt.detail.id :",typeof(evt.detail.id));

        // dial them when we discover them

        node.dial(evt.detail.id).catch((err) => {

          console.log(`Could not dial ${evt.detail.id}`, err);

        });

      });

      // Listen for new connections to peers

      node.connectionManager.addEventListener("peer:connect", (evt) => {

        const connection = evt.detail;

        console.log(`Connected to ${connection.remotePeer.toString()}`);

      });

      // Listen for peers disconnecting

      node.connectionManager.addEventListener("peer:disconnect", (evt) => {

        const connection = evt.detail;

        console.log(`Disconnected from ${connection.remotePeer.toString()}`)

      });

//     node.pubsub.subscribe("opposite of god");

// node.pubsub.addEventListener("message", (evt) => {

//   console.warn("message receiver runs")

//   setMsg(uint8ArrayToString(evt.detail.data));

//   console.warn(`data received: ${uint8ArrayToString(evt.detail.data)} on topic ${evt.detail.topic}`)

//   // store(

//   //   `<<-- ${uint8ArrayToString(evt.detail.data)} on topic ${evt.detail.topic}`

//   // );

// });

}catch(e){console.log("try error: ",e)}

  

} // end of start

  const listenMessage = async()=>{

    console.log("listen msg running")

   

     nodE.pubsub.subscribe("opposite of god");

     nodE.pubsub.addEventListener("message", (evt) => {

       console.log("message receiver runs");

       setMsg(uint8ArrayToString(evt.detail.data));

       console.log(

         `data received: ${uint8ArrayToString(evt.detail.data)} on topic ${

           evt.detail.topic

         }`

       );

       // store(

       //   `<<-- ${uint8ArrayToString(evt.detail.data)} on topic ${evt.detail.topic}`

       // );

     });

  }

    const find = async (aPeerId) => {

       //connect to peer

       const anId = peerIdFromString(aPeerId);

       const hasData = Boolean(nodE.peerStore.get(anId));

       alert(`has found peer: ${hasData}`);

     };

    const send = async (_msg) => {

      console.log("send running")

      nodE.pubsub.publish("opposite of god", uint8ArrayFromString(_msg))

         .catch((err) => {

           console.error("err of send :   ",err);

         })

         .then(() => {

           //  store("-->> " + msg);

         });

     };

    // const store = (m) => {

    //    const arr = state.log;

    //    if (arr.length > 50) arr.shift();

    //    arr.push(m);

    //    setState({ log: arr });

    //  };

    const connect = async()=>{

      const peerMultiaddr = {

        family: "ipv4",

        address: "/dns4/wrtc-star1.par.dwebops.pub",

        port: 443,

        transport: "tcp",

        peerId: peers,

      };

      

      // peerId: `/p2p/`+peers,

       alert(peers)

      const connection = await nodE.dial(peers);

     console.warn("connecting to node : ",connection)

  const stream = connection.newStream()

  stream.write('Hello, world!')

  stream.end()

    }

  const listenStream = async()=>{

      console.warn("listening stream")

     stream.on("data", (data) => {

       console.warn("Received:", data.toString());

     });

  }

    useEffect(()=>{

     console.log("useEffect for msg",msg)

    },[msg])

  

    return (

      <>

        


          


            


              Your ID{" "}

              

                {peerId}

              

            

          

          


            

                setPeers(

                  `/dns4/wrtc-star1.par.dwebops.pub/tcp/443/wss/p2p-webrtc-star/p2p/` +

                    e.target.value

                )

                // setPeers(e.target.value)

              }

            />

            


              find()}

                onClick={() => connect()}

              >

                connect

              

            

          


          


            

          


          


            

            


               send("it's working on friday")}

              >

                send

              

            

             start()}>

              start

            

             listenMessage()}

              // onClick={() => listenStream()}

            >

              listen

            

          


          {/*  setPeers(e.target.value)} /> */}

          {/*  send("fuck u")}>send */}

          {/*  find(peers)}>find */}

        

      >

    );

}


export default chatCore;