@leofcoin/peernet 1.1.80 → 1.1.81

package/test/peernet.test.js

@@ -1,159 +1,159 @@
-import Peernet from '../exports/peernet.js'
-import Identity from '../exports/identity.js'
-import { expect } from 'chai'
-import sinon from 'sinon'
-import networks from '@leofcoin/networks'
-
-const network = networks.leofcoin.peach
-
-let options
-let password
-options = {
-  network: 'leofcoin:peach',
-  stars: network.stars,
-  root: '.testnet',
-  version: '1.0.0',
-  storePrefix: 'test'
-}
-password = 'password'
-const peernet = await new Peernet(options, password)
-
-describe('Peernet', async () => {
-  // beforeEach(async () => {
-  // })
-
-  it('should initialize with the correct network', () => {
-    expect(peernet.network).to.equal('leofcoin:peach')
-  })
-
-  it('should initialize with the correct version', () => {
-    expect(peernet.version).to.equal('1.0.0')
-  })
-
-  it('should initialize with the correct store prefix', () => {
-    expect(peernet.storePrefix).to.equal('test')
-  })
-
-  it('should have an identity instance', () => {
-    expect(peernet.identity).to.be.instanceOf(Identity)
-  })
-
-  it('should have a DHT instance', () => {
-    expect(peernet.dht).to.not.be.undefined
-  })
-
-  it('should start the client', async () => {
-    const startSpy = sinon.spy(peernet, 'start')
-    await peernet.start()
-    expect(startSpy.calledOnce).to.be.true
-  })
-
-  it('should add a proto', () => {
-    const protoName = 'test-proto'
-    const proto = {}
-    peernet.addProto(protoName, proto)
-    expect(globalThis.peernet.protos[protoName]).to.equal(proto)
-  })
-
-  it('should add a codec', () => {
-    const codec = { name: 'test-codec' }
-    const addCodecSpy = sinon.spy(peernet, 'addCodec')
-    peernet.addCodec(codec)
-    expect(addCodecSpy.calledOnceWith(codec)).to.be.true
-  })
-
-  it('should select an account', async () => {
-    const account = 'test-account'
-    const selectAccountSpy = sinon.spy(peernet.identity, 'selectAccount')
-    await peernet.selectAccount(account)
-    expect(selectAccountSpy.calledOnceWith(account)).to.be.true
-  })
-
-  it('should prepare a message', () => {
-    const data = { message: 'test' }
-    const prepareMessageSpy = sinon.spy(peernet._messageHandler, 'prepareMessage')
-    peernet.prepareMessage(data)
-    expect(prepareMessageSpy.calledOnceWith(data)).to.be.true
-  })
-
-  it('should get peers', () => {
-    const peers = peernet.peers
-    expect(peers).to.be.an('array')
-  })
-
-  it('should get connections', () => {
-    const connections = peernet.connections
-    expect(connections).to.be.an('object')
-  })
-
-  it('should get a connection by id', () => {
-    const id = 'test-id'
-    const connection = peernet.getConnection(id)
-    expect(connection).to.be.undefined // Assuming no connections are established in the test
-  })
-
-  // it('should handle DHT', async () => {
-  //   const peer = {}
-  //   const id = 'test-id'
-  //   const proto = { decoded: { hash: 'test-hash', store: 'test-store' } }
-  //   const handleDHTSpy = sinon.spy(peernet, 'handleDHT')
-  //   await peernet.handleDHT(peer, id, proto)
-  //   expect(handleDHTSpy.calledOnceWith(peer, id, proto)).to.be.true
-  // })
-
-  it('should handle data', async () => {
-    const peer = {}
-    const id = 'test-id'
-    const proto = { decoded: { hash: 'test-hash', store: 'test-store' } }
-    const handleDataSpy = sinon.spy(peernet, 'handleData')
-    await peernet.handleData(peer, id, proto)
-    expect(handleDataSpy.calledOnceWith(peer, id, proto)).to.be.true
-  })
-
-  it('should handle request', async () => {
-    const peer = {}
-    const id = 'test-id'
-    const proto = { decoded: { request: 'test-request' } }
-    const handleRequestSpy = sinon.spy(peernet, 'handleRequest')
-    await peernet.handleRequest(peer, id, proto)
-    expect(handleRequestSpy.calledOnceWith(peer, id, proto)).to.be.true
-  })
-
-  it('should walk the network', async () => {
-    const hash = 'test-hash'
-    const walkSpy = sinon.spy(peernet, 'walk')
-    await peernet.walk(hash)
-    expect(walkSpy.calledOnceWith(hash)).to.be.true
-  })
-
-  // it('should find providers for a hash', async () => {
-  //   const hash = 'test-hash'
-  //   const providers = await peernet.providersFor(hash)
-  //   expect(providers).to.be.undefined // Assuming no providers are found in the test
-  // })
-
-  // it('should request data', async () => {
-  //   const hash = 'test-hash'
-  //   const requestDataSpy = sinon.spy(peernet, 'requestData')
-  //   await peernet.requestData(hash, 'data')
-  //   expect(requestDataSpy.calledOnceWith(hash, 'data')).to.be.true
-  // })
-
-  it('should publish data', async () => {
-    const topic = 'test-topic'
-    const data = 'test-data'
-    const publishSpy = sinon.spy(peernet, 'publish')
-    await peernet.publish(topic, data)
-    expect(publishSpy.calledOnceWith(topic, data)).to.be.true
-  })
-
-  it('should subscribe to a topic', async () => {
-    const topic = 'test-topic'
-    const callback = sinon.spy()
-    const subscribeSpy = sinon.spy(peernet, 'subscribe')
-    await peernet.subscribe(topic, callback)
-    expect(subscribeSpy.calledOnceWith(topic, callback)).to.be.true
-
-    process.exit()
-  })
-})
+import Peernet from '../exports/peernet.js'
+import Identity from '../exports/identity.js'
+import { expect } from 'chai'
+import sinon from 'sinon'
+import networks from '@leofcoin/networks'
+
+const network = networks.leofcoin.peach
+
+let options
+let password
+options = {
+  network: 'leofcoin:peach',
+  stars: network.stars,
+  root: '.testnet',
+  version: '1.0.0',
+  storePrefix: 'test'
+}
+password = 'password'
+const peernet = await new Peernet(options, password)
+
+describe('Peernet', async () => {
+  // beforeEach(async () => {
+  // })
+
+  it('should initialize with the correct network', () => {
+    expect(peernet.network).to.equal('leofcoin:peach')
+  })
+
+  it('should initialize with the correct version', () => {
+    expect(peernet.version).to.equal('1.0.0')
+  })
+
+  it('should initialize with the correct store prefix', () => {
+    expect(peernet.storePrefix).to.equal('test')
+  })
+
+  it('should have an identity instance', () => {
+    expect(peernet.identity).to.be.instanceOf(Identity)
+  })
+
+  it('should have a DHT instance', () => {
+    expect(peernet.dht).to.not.be.undefined
+  })
+
+  it('should start the client', async () => {
+    const startSpy = sinon.spy(peernet, 'start')
+    await peernet.start()
+    expect(startSpy.calledOnce).to.be.true
+  })
+
+  it('should add a proto', () => {
+    const protoName = 'test-proto'
+    const proto = {}
+    peernet.addProto(protoName, proto)
+    expect(globalThis.peernet.protos[protoName]).to.equal(proto)
+  })
+
+  it('should add a codec', () => {
+    const codec = { name: 'test-codec' }
+    const addCodecSpy = sinon.spy(peernet, 'addCodec')
+    peernet.addCodec(codec)
+    expect(addCodecSpy.calledOnceWith(codec)).to.be.true
+  })
+
+  it('should select an account', async () => {
+    const account = 'test-account'
+    const selectAccountSpy = sinon.spy(peernet.identity, 'selectAccount')
+    await peernet.selectAccount(account)
+    expect(selectAccountSpy.calledOnceWith(account)).to.be.true
+  })
+
+  it('should prepare a message', () => {
+    const data = { message: 'test' }
+    const prepareMessageSpy = sinon.spy(peernet._messageHandler, 'prepareMessage')
+    peernet.prepareMessage(data)
+    expect(prepareMessageSpy.calledOnceWith(data)).to.be.true
+  })
+
+  it('should get peers', () => {
+    const peers = peernet.peers
+    expect(peers).to.be.an('array')
+  })
+
+  it('should get connections', () => {
+    const connections = peernet.connections
+    expect(connections).to.be.an('object')
+  })
+
+  it('should get a connection by id', () => {
+    const id = 'test-id'
+    const connection = peernet.getConnection(id)
+    expect(connection).to.be.undefined // Assuming no connections are established in the test
+  })
+
+  // it('should handle DHT', async () => {
+  //   const peer = {}
+  //   const id = 'test-id'
+  //   const proto = { decoded: { hash: 'test-hash', store: 'test-store' } }
+  //   const handleDHTSpy = sinon.spy(peernet, 'handleDHT')
+  //   await peernet.handleDHT(peer, id, proto)
+  //   expect(handleDHTSpy.calledOnceWith(peer, id, proto)).to.be.true
+  // })
+
+  it('should handle data', async () => {
+    const peer = {}
+    const id = 'test-id'
+    const proto = { decoded: { hash: 'test-hash', store: 'test-store' } }
+    const handleDataSpy = sinon.spy(peernet, 'handleData')
+    await peernet.handleData(peer, id, proto)
+    expect(handleDataSpy.calledOnceWith(peer, id, proto)).to.be.true
+  })
+
+  it('should handle request', async () => {
+    const peer = {}
+    const id = 'test-id'
+    const proto = { decoded: { request: 'test-request' } }
+    const handleRequestSpy = sinon.spy(peernet, 'handleRequest')
+    await peernet.handleRequest(peer, id, proto)
+    expect(handleRequestSpy.calledOnceWith(peer, id, proto)).to.be.true
+  })
+
+  it('should walk the network', async () => {
+    const hash = 'test-hash'
+    const walkSpy = sinon.spy(peernet, 'walk')
+    await peernet.walk(hash)
+    expect(walkSpy.calledOnceWith(hash)).to.be.true
+  })
+
+  // it('should find providers for a hash', async () => {
+  //   const hash = 'test-hash'
+  //   const providers = await peernet.providersFor(hash)
+  //   expect(providers).to.be.undefined // Assuming no providers are found in the test
+  // })
+
+  // it('should request data', async () => {
+  //   const hash = 'test-hash'
+  //   const requestDataSpy = sinon.spy(peernet, 'requestData')
+  //   await peernet.requestData(hash, 'data')
+  //   expect(requestDataSpy.calledOnceWith(hash, 'data')).to.be.true
+  // })
+
+  it('should publish data', async () => {
+    const topic = 'test-topic'
+    const data = 'test-data'
+    const publishSpy = sinon.spy(peernet, 'publish')
+    await peernet.publish(topic, data)
+    expect(publishSpy.calledOnceWith(topic, data)).to.be.true
+  })
+
+  it('should subscribe to a topic', async () => {
+    const topic = 'test-topic'
+    const callback = sinon.spy()
+    const subscribeSpy = sinon.spy(peernet, 'subscribe')
+    await peernet.subscribe(topic, callback)
+    expect(subscribeSpy.calledOnceWith(topic, callback)).to.be.true
+
+    process.exit()
+  })
+})

package/test.js

@@ -1,62 +1,62 @@
-import Client from './exports/peernet.js'
-
-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()
-// })
+import Client from './exports/peernet.js'
+
+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,13 +1,13 @@
-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()
-  }, 10000)
-})()
+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()
+  }, 10000)
+})()

package/test3.js

@@ -1,16 +1,16 @@
-const Client = require('./dist/commonjs/peernet.js')
-const PeernetMessage = require('./dist/messages/peernet.js');
-const DHTMessage = require('./dist/messages/dht.js');
-
-globalThis.DEBUG = true;
-const client = new Client({root: '.peernet/test3'})
-
-pubsub.subscribe('peer:connected', async peer => setInterval(async () => {
-  // const dhtMessage = new DHTMessage({hash: 'hello'})
-  // console.log(dhtMessage.encoded);
-  // const message = new PeernetMessage({ from: client.id, to: peer.id, data: dhtMessage.encoded, signature: Buffer.from('pnsig') })
-  // console.log(message.encoded);
-  //   console.log(await peer.request(message.encoded));
-  const data = await client.get('hello')
-  console.log(data.toString())
+const Client = require('./dist/commonjs/peernet.js')
+const PeernetMessage = require('./dist/messages/peernet.js');
+const DHTMessage = require('./dist/messages/dht.js');
+
+globalThis.DEBUG = true;
+const client = new Client({root: '.peernet/test3'})
+
+pubsub.subscribe('peer:connected', async peer => setInterval(async () => {
+  // const dhtMessage = new DHTMessage({hash: 'hello'})
+  // console.log(dhtMessage.encoded);
+  // const message = new PeernetMessage({ from: client.id, to: peer.id, data: dhtMessage.encoded, signature: Buffer.from('pnsig') })
+  // console.log(message.encoded);
+  //   console.log(await peer.request(message.encoded));
+  const data = await client.get('hello')
+  console.log(data.toString())
 }, 5000))

package/test4.js

@@ -1,7 +1,7 @@
-const Client = require('./dist/commonjs/peernet.js')
-
-const client = new Client({root: '.peernet/test4'})
-
-pubsub.subscribe('peer:connected', async peer => {
-  await peernet.get("ba5xcadcnub27naa7zrcvtmyruviahaiwvupatfgjkvdgcehuif7clissf")
-})
+const Client = require('./dist/commonjs/peernet.js')
+
+const client = new Client({root: '.peernet/test4'})
+
+pubsub.subscribe('peer:connected', async peer => {
+  await peernet.get("ba5xcadcnub27naa7zrcvtmyruviahaiwvupatfgjkvdgcehuif7clissf")
+})

package/tsconfig.json

@@ -1,11 +1,11 @@
-{
-  "compilerOptions": {
-    "module": "NodeNext",
-    "target": "ESNext",
-    "declaration": true,
-    "outDir": "./exports",
-    "moduleResolution": "NodeNext",
-    "allowJs": true
-  },
-  "include": ["./src/**/*"]
-}
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "target": "ESNext",
+    "declaration": true,
+    "outDir": "./exports",
+    "moduleResolution": "NodeNext",
+    "allowJs": true
+  },
+  "include": ["./src/**/*"]
+}