@leofcoin/peernet 2.0.0 → 3.0.0

package/test/peernet.test.js

@@ -1,477 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { readFile } from 'node:fs/promises'
-import { execFile } from 'node:child_process'
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { promisify } from 'node:util'
-
-import Peernet from '../exports/peernet.js'
-import Identity, { resolveAccountWallets } from '../exports/identity.js'
-import MultiWallet from '@leofcoin/multi-wallet'
-import { Codec, CodecHash } from '@leofcoin/codec-format-interface'
-import { fromBase58, toBase58 } from '@vandeurenglenn/typed-array-utils'
-
-const options = {
-  network: 'leofcoin:peach',
-  stars: [],
-  root: `.testnet-${process.pid}`,
-  version: '1.0.0',
-  storePrefix: 'test',
-  autoStart: false
-}
-
-const password = 'password'
-const peernet = await new Peernet(options, password)
-const execFileAsync = promisify(execFile)
-
-test('freshIdentity initializes against a completely empty store root', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'peernet-fresh-identity-'))
-  try {
-    const { stdout } = await execFileAsync(process.execPath, ['test/fresh-empty-store.js', root], {
-      cwd: new URL('..', import.meta.url),
-      timeout: 20_000
-    })
-    assert.match(stdout, /FRESH_IDENTITY_READY/)
-  } finally {
-    await rm(root, { recursive: true, force: true })
-  }
-})
-
-test('node bundle uses a portable password prompt import', async () => {
-  const identityBundle = await readFile(new URL('../exports/identity.js', import.meta.url), 'utf8')
-  assert.match(identityBundle, /import\(['"]\.\/prompts\/password\.js['"]\)/)
-  assert.doesNotMatch(identityBundle, /(?:\/home\/|\/Users\/|[A-Za-z]:\\)/)
-})
-
-test('initializes with provided options', () => {
-  assert.equal(peernet.network, options.network)
-  assert.equal(peernet.version, options.version)
-  assert.equal(peernet.storePrefix, options.storePrefix)
-})
-
-test('exposes identity instance', () => {
-  assert.ok(peernet.identity instanceof Identity)
-})
-
-test('built peernet messages use canonical codec-first hashes', async () => {
-  const message = new peernet.protos['peernet-ps']({ data: new Uint8Array([1, 2, 3]), topic: new Uint8Array([4]) })
-  const hash = new CodecHash()
-  hash.fromBs32(await message.hash())
-  assert.equal(hash.name, 'peernet-ps')
-  assert.equal(hash.size, hash.digest.length)
-  const codec = new Codec('peernet-ps').encode()
-  assert.deepEqual(hash.encoded.subarray(0, codec.length), codec)
-  assert.deepEqual(hash.encoded, new Uint8Array([...codec, ...hash.length, ...hash.digest]))
-  const roundTrip = new peernet.protos['peernet-ps'](message.encoded)
-  assert.equal(await roundTrip.hash(), hash.toBs32())
-  assert.deepEqual(roundTrip.decoded.data, message.decoded.data)
-})
-
-test('hash parser rejects old length-first peernet content addresses', async () => {
-  const message = new peernet.protos['peernet-ps']({ data: new Uint8Array([1, 2, 3]), topic: new Uint8Array([4]) })
-  const hash = new CodecHash()
-  hash.fromBs32(await message.hash())
-  const previousFormat = new Uint8Array([...hash.length, ...hash.codec, ...hash.digest])
-  assert.throws(() => new CodecHash().decode(previousFormat))
-})
-
-test('release dependency graph contains only codec 2.x and no Git varint fallback', async () => {
-  const manifest = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8'))
-  const lock = JSON.parse(await readFile(new URL('../package-lock.json', import.meta.url), 'utf8'))
-  assert.equal(manifest.dependencies['@leofcoin/codec-format-interface'], '^2.0.0')
-  assert.equal(lock.packages[''].version, manifest.version)
-  const codecs = Object.entries(lock.packages).filter(([name]) => name.endsWith('/@leofcoin/codec-format-interface'))
-  assert.equal(codecs.length, 1)
-  assert.equal(codecs[0][1].version, '2.0.0')
-  for (const [name, entry] of Object.entries(lock.packages)) {
-    assert.ok(!name.endsWith('/varint'), name)
-    assert.ok(!/^(git\+|git:|github:|file:)/.test(entry.resolved ?? ''), name)
-  }
-})
-
-test('freshIdentity replaces a persisted identity and signer', async () => {
-  const originalId = peernet.id
-  const originalAccount = peernet.selectedAccount
-  const replacement = await new Peernet({ ...options, freshIdentity: true }, password)
-
-  assert.notEqual(replacement.id, originalId)
-  assert.notEqual(replacement.selectedAccount, originalAccount)
-  assert.equal(new TextDecoder().decode(await globalThis.walletStore.get('selected-account')), replacement.selectedAccount)
-})
-
-test('has a DHT instance', () => {
-  assert.ok(peernet.dht)
-})
-
-test('returns peers and connections safely', () => {
-  assert.deepEqual(peernet.peers, [])
-  assert.deepEqual(peernet.connections, {})
-  assert.equal(peernet.getConnection('missing'), undefined)
-})
-
-test('provides callable helpers', () => {
-  assert.equal(typeof peernet.addProto, 'function')
-  assert.equal(typeof peernet.addCodec, 'function')
-  assert.equal(typeof peernet.prepareMessage, 'function')
-  assert.equal(typeof peernet.publish, 'function')
-  assert.equal(typeof peernet.subscribe, 'function')
-})
-
-test('pubsub subscribe registers callback', async () => {
-  const topic = 'test-topic'
-  let callbackCalled = false
-
-  const callback = () => {
-    callbackCalled = true
-  }
-
-  // Subscribe to topic
-  await peernet.subscribe(topic, callback)
-
-  // Manually publish to globalSub to test subscription registration
-  globalThis.globalSub.publish(topic, 'test-data')
-
-  // Give async operation a moment to process
-  await new Promise((resolve) => setTimeout(resolve, 10))
-
-  assert.ok(callbackCalled)
-})
-
-test('addProto registers protocol', () => {
-  const protoName = 'test-protocol'
-  const protoObject = { test: 'data' }
-
-  peernet.addProto(protoName, protoObject)
-
-  assert.equal(globalThis.peernet.protos[protoName], protoObject)
-})
-
-test('addProto does not overwrite existing protocol', () => {
-  const protoName = 'existing-proto'
-  const originalProto = { original: true }
-  const newProto = { new: true }
-
-  peernet.addProto(protoName, originalProto)
-  const firstRegistered = globalThis.peernet.protos[protoName]
-
-  peernet.addProto(protoName, newProto)
-  const afterSecondAdd = globalThis.peernet.protos[protoName]
-
-  assert.equal(firstRegistered, originalProto)
-  assert.equal(afterSecondAdd, originalProto)
-})
-
-test('addCodec is callable', () => {
-  const mockCodec = { name: 'test-codec' }
-  // addCodec may return undefined, just verify it doesn't throw
-  assert.equal(typeof peernet.addCodec, 'function')
-  peernet.addCodec(mockCodec)
-})
-
-test('selectAccount delegates to identity', () => {
-  const accountName = 'test-account'
-  // selectAccount may return undefined, just verify it doesn't throw
-  assert.equal(typeof peernet.selectAccount, 'function')
-})
-
-test('identity has loaded account data', () => {
-  assert.ok(peernet.identity.accounts !== undefined)
-  assert.ok(peernet.identity.selectedAccount !== undefined)
-})
-
-test('peerId matches identity id', () => {
-  assert.equal(peernet.peerId, peernet.identity.id)
-  assert.equal(peernet.id, peernet.identity.id)
-})
-
-test('data store operations', () => {
-  const hash = 'test-hash-123'
-  const testData = new Uint8Array([1, 2, 3, 4, 5])
-
-  // Test put operation - may hang, so just verify method exists
-  assert.equal(typeof peernet.put, 'function')
-
-  // Test has operation - verify method exists
-  assert.equal(typeof peernet.has, 'function')
-})
-
-test('get attempts to retrieve from store', async () => {
-  const hash = 'nonexistent-hash'
-  // Just verify method exists
-  assert.equal(typeof peernet.get, 'function')
-})
-
-test('message object provides get/put/has', () => {
-  const messageObj = peernet.message
-  assert.equal(typeof messageObj.get, 'function')
-  assert.equal(typeof messageObj.put, 'function')
-  assert.equal(typeof messageObj.has, 'function')
-})
-
-test('data object provides get/put/has', () => {
-  const dataObj = peernet.data
-  assert.equal(typeof dataObj.get, 'function')
-  assert.equal(typeof dataObj.put, 'function')
-  assert.equal(typeof dataObj.has, 'function')
-})
-
-test('block object provides get/put/has', () => {
-  const blockObj = peernet.block
-  assert.equal(typeof blockObj.get, 'function')
-  assert.equal(typeof blockObj.put, 'function')
-  assert.equal(typeof blockObj.has, 'function')
-})
-
-test('large blocks are chunked internally and reconstructed transparently', async () => {
-  const previousThreshold = peernet.blockChunkThreshold
-  const previousChunkSize = peernet.blockChunkSize
-  peernet.blockChunkThreshold = 512
-  peernet.blockChunkSize = 256
-  try {
-    const hash = `chunked-block-${Date.now()}`
-    const block = new Uint8Array(1537)
-    for (let index = 0; index < block.length; index++) block[index] = index % 251
-
-    await peernet.block.put(hash, block)
-    const stored = await globalThis.blockStore.get(hash)
-    const manifest = new peernet.protos['peernet-file'](stored)
-    await manifest.decode()
-
-    assert.equal(manifest.decoded.kind, 'block')
-    assert.equal(manifest.decoded.blockHash, hash)
-    assert.equal(manifest.decoded.links.length, 7)
-    assert.deepEqual(await peernet.block.get(hash), block)
-  } finally {
-    peernet.blockChunkThreshold = previousThreshold
-    peernet.blockChunkSize = previousChunkSize
-  }
-})
-
-test('transaction object provides get/put/has', () => {
-  const txObj = peernet.transaction
-  assert.equal(typeof txObj.get, 'function')
-  assert.equal(typeof txObj.put, 'function')
-  assert.equal(typeof txObj.has, 'function')
-})
-
-test('folder object provides get/put/has', () => {
-  const folderObj = peernet.folder
-  assert.equal(typeof folderObj.get, 'function')
-  assert.equal(typeof folderObj.put, 'function')
-  assert.equal(typeof folderObj.has, 'function')
-})
-
-test('Buffer property is available', () => {
-  assert.ok(peernet.Buffer)
-  assert.equal(peernet.Buffer, Buffer)
-})
-
-test('handleData is callable', () => {
-  assert.equal(typeof peernet.handleData, 'function')
-})
-
-test('handleDHT is callable', () => {
-  assert.equal(typeof peernet.handleDHT, 'function')
-})
-
-test('handleRequest is callable', () => {
-  assert.equal(typeof peernet.handleRequest, 'function')
-})
-
-test('walk is callable', () => {
-  assert.equal(typeof peernet.walk, 'function')
-})
-
-test('providersFor is callable', () => {
-  assert.equal(typeof peernet.providersFor, 'function')
-})
-
-test('addRequestHandler is callable', () => {
-  assert.equal(typeof peernet.addRequestHandler, 'function')
-})
-
-test('sendMessage is callable', () => {
-  assert.equal(typeof peernet.sendMessage, 'function')
-})
-
-test('start method exists', () => {
-  // Just verify method exists and is callable
-  assert.equal(typeof peernet.start, 'function')
-})
-
-test('default stores are initialized', () => {
-  const defaultStores = peernet.defaultStores
-  assert.ok(Array.isArray(defaultStores))
-  assert.ok(defaultStores.includes('account'))
-  assert.ok(defaultStores.includes('wallet'))
-  assert.ok(defaultStores.includes('block'))
-  assert.ok(defaultStores.includes('transaction'))
-  assert.ok(defaultStores.includes('chain'))
-  assert.ok(defaultStores.includes('data'))
-  assert.ok(defaultStores.includes('message'))
-  assert.ok(defaultStores.includes('share'))
-})
-
-test('identity has all expected methods', () => {
-  assert.equal(typeof peernet.identity.sign, 'function')
-  assert.equal(typeof peernet.identity.export, 'function')
-  assert.equal(typeof peernet.identity.import, 'function')
-  assert.equal(typeof peernet.identity.lock, 'function')
-  assert.equal(typeof peernet.identity.unlock, 'function')
-  assert.equal(typeof peernet.identity.getAccounts, 'function')
-})
-
-test('identity wallet is loaded', () => {
-  assert.ok(peernet.identity.id)
-  assert.ok(typeof peernet.identity.id === 'string')
-  assert.ok(peernet.identity.id.length > 0)
-})
-
-test('selected account is set', () => {
-  assert.ok(peernet.identity.selectedAccount)
-  assert.ok(typeof peernet.identity.selectedAccount === 'string')
-})
-
-test('identity signatures authenticate the selected account', async () => {
-  const payload = new Uint8Array(32).fill(7)
-  const signature = toBase58(await peernet.identity.sign(payload))
-  const verifier = new MultiWallet(peernet.network)
-  await verifier.fromAddress(peernet.selectedAccount, null, peernet.network)
-  assert.equal(await verifier.verify(fromBase58(signature), payload), true)
-})
-
-test('legacy account(0)/address(0) identities keep their original signer', async () => {
-  const wallet = new MultiWallet(peernet.network)
-  await wallet.generate()
-  const legacyAccount = wallet.account(0)
-  const external = await legacyAccount.external(0)
-  const internal = await legacyAccount.internal(0)
-  const externalAddress = await external.address
-  const wallets = await resolveAccountWallets(wallet, [
-    ['legacy account', externalAddress, await internal.address]
-  ])
-  const payload = new Uint8Array(32).fill(9)
-  const signature = toBase58(await wallets.get(externalAddress).sign(payload))
-  const verifier = new MultiWallet(peernet.network)
-  await verifier.fromAddress(externalAddress, null, peernet.network)
-  assert.equal(await verifier.verify(fromBase58(signature), payload), true)
-})
-
-test('error handling methods exist', () => {
-  assert.equal(typeof peernet.handleDHT, 'function')
-  assert.equal(typeof peernet.handleData, 'function')
-  assert.equal(typeof peernet.handleRequest, 'function')
-})
-
-test('in-memory broadcast and handleData returns correct data', async () => {
-  // Broadcast a valid file object with path
-  const testString = 'hello in-memory world'
-  const path = '/test'
-  const content = new TextEncoder().encode(testString)
-
-  const hash = await peernet.broadcast(path, { content })
-
-  // Prepare a mock peer and capture sendMessage output
-  let sentNode = null
-  const mockPeer = {
-    connected: true,
-    send: async (data, id) => {
-      sentNode = { data, id }
-      return Promise.resolve()
-    }
-  }
-  const proto = {
-    decoded: { hash }
-  }
-  await peernet.handleData(mockPeer, 'test-id', proto)
-
-  assert.ok(sentNode)
-  const DataResponseProto = globalThis.peernet.protos['peernet-data-response']
-  const decodedProto = await new DataResponseProto(sentNode.data)
-  await decodedProto.decode()
-  const FileProto = globalThis.peernet.protos['peernet-file']
-  const decodedFile = new FileProto(decodedProto.decoded.data)
-  await decodedFile.decode()
-  const decodedContent = new TextDecoder().decode(decodedFile.decoded.content)
-  assert.equal(decodedProto.decoded.hash, hash)
-  assert.equal(decodedContent, testString)
-})
-
-test('in-memory broadcast and handleData supports large binary data', async () => {
-  // Create a large binary buffer (e.g., 1MB)
-  const size = 1024 * 1024 // 1MB
-  const largeBuffer = new Uint8Array(size)
-  for (let i = 0; i < size; i++) largeBuffer[i] = i % 256
-  const path = '/large-binary'
-  const content = largeBuffer
-  const hash = await peernet.broadcast(path, { content })
-
-  // Prepare a mock peer and capture sendMessage output
-  let sentNode = null
-  const mockPeer = {
-    connected: true,
-    send: async (data, id) => {
-      sentNode = { data, id }
-      return Promise.resolve()
-    }
-  }
-  const proto = {
-    decoded: { hash }
-  }
-  await peernet.handleData(mockPeer, 'test-id', proto)
-
-  assert.ok(sentNode)
-  const DataResponseProto = globalThis.peernet.protos['peernet-data-response']
-  const decodedProto = await new DataResponseProto(sentNode.data)
-  await decodedProto.decode()
-  assert.equal(decodedProto.decoded.hash, hash)
-  const transfer = peernet.download(hash)
-  const receivedBuffer = Buffer.from(await transfer.result)
-  const originalBuffer = Buffer.from(largeBuffer)
-  assert.equal(Buffer.compare(receivedBuffer, originalBuffer), 0)
-})
-
-test('share object provides get/put/has', () => {
-  const shareObj = peernet.share
-  assert.equal(typeof shareObj.get, 'function')
-  assert.equal(typeof shareObj.put, 'function')
-  assert.equal(typeof shareObj.has, 'function')
-})
-
-test('allSharedHashes method exists and is callable', () => {
-  assert.equal(typeof peernet.allSharedHashes, 'function')
-})
-
-test('broadcast persists to share store', async () => {
-  const testString = 'test broadcast content'
-  const path = '/broadcast-test'
-  const content = new TextEncoder().encode(testString)
-
-  const hash = await peernet.broadcast(path, { content })
-
-  // Verify it was stored in share store
-  assert.ok(hash)
-  const hasInShare = await peernet.share.has(hash)
-  assert.equal(hasInShare, true)
-})
-
-test('share store can retrieve broadcasted content', async () => {
-  const testString = 'retrievable broadcast content'
-  const path = '/retrievable-test'
-  const content = new TextEncoder().encode(testString)
-
-  const hash = await peernet.broadcast(path, { content })
-
-  // Verify we can retrieve it from share store
-  const storedData = await peernet.share.get(hash)
-  assert.ok(storedData)
-})
-
-test('allSharedHashes returns array of hashes', async () => {
-  const hashes = await peernet.allSharedHashes()
-  assert.ok(Array.isArray(hashes))
-  // Should contain at least the hashes we broadcasted in previous tests
-  assert.ok(hashes.length >= 0)
-})

package/test-output.log

@@ -1,84 +0,0 @@
-✔ initializes with provided options (0.407125ms)
-✔ exposes identity instance (0.051667ms)
-✔ has a DHT instance (0.04425ms)
-✔ returns peers and connections safely (0.267542ms)
-✔ provides callable helpers (0.048958ms)
-✔ pubsub subscribe registers callback (10.395584ms)
-✔ addProto registers protocol (0.160417ms)
-✔ addProto does not overwrite existing protocol (0.057709ms)
-✔ addCodec is callable (0.063084ms)
-✔ selectAccount delegates to identity (0.068584ms)
-✔ identity has loaded account data (0.241875ms)
-✔ peerId matches identity id (0.031375ms)
-✔ data store operations (0.030125ms)
-✔ get attempts to retrieve from store (0.035667ms)
-✔ message object provides get/put/has (0.053917ms)
-✔ data object provides get/put/has (0.045833ms)
-✔ block object provides get/put/has (0.067375ms)
-✔ transaction object provides get/put/has (0.042333ms)
-✔ folder object provides get/put/has (0.034167ms)
-✔ Buffer property is available (0.024417ms)
-✔ handleData is callable (0.017709ms)
-✔ handleDHT is callable (0.016167ms)
-✔ handleRequest is callable (0.016417ms)
-✔ walk is callable (0.015459ms)
-✔ providersFor is callable (0.015583ms)
-✔ addRequestHandler is callable (0.015375ms)
-✔ sendMessage is callable (0.01625ms)
-✔ start method exists (0.02675ms)
-✔ default stores are initialized (0.0275ms)
-✔ identity has all expected methods (0.020084ms)
-✔ identity wallet is loaded (0.019333ms)
-✔ selected account is set (0.016208ms)
-✔ error handling methods exist (0.017083ms)
-DEBUG_HANDLE_DATA: entering in-memory branch { hash: 'BA43QACTNQLBH6SW7NO7ZQ63I3USRUBTD5DOWLEUFJGMY6JN2BSUAES54X' }
-DEBUG_HANDLE_DATA: got from _inMemoryBroadcasts {
-  type: 'object',
-  isUint8Array: true,
-  length: 34,
-  slice: [
-    230, 224,   1,   5,  47,
-    116, 101, 115, 116,  21,
-    104, 101, 108, 108, 111,
-     32
-  ]
-}
-✔ in-memory broadcast and handleData returns correct data (4.52275ms)
-DEBUG_HANDLE_DATA: entering in-memory branch { hash: 'BA43QACYLVOY2HRRGV4NOUDQ3GWPQ7YZVBBM5DOKGZIY4UOYMS3K3JSCVV' }
-DEBUG_HANDLE_DATA: got from _inMemoryBroadcasts {
-  type: 'object',
-  isUint8Array: true,
-  length: 1048599,
-  slice: [
-    230, 224,   1,  13, 47, 108,
-     97, 114, 103, 101, 45,  98,
-    105, 110,  97, 114
-  ]
-}
-DEBUG_TEST receivedBuffer {
-  type: 'object',
-  isUint8Array: true,
-  length: 1048576,
-  slice: [
-     0,  1,  2,  3,  4,  5,
-     6,  7,  8,  9, 10, 11,
-    12, 13, 14, 15
-  ]
-}
-DEBUG_TEST originalBuffer {
-  length: 1048576,
-  slice: [
-     0,  1,  2,  3,  4,  5,
-     6,  7,  8,  9, 10, 11,
-    12, 13, 14, 15
-  ]
-}
-✔ in-memory broadcast and handleData supports large binary data (163.195292ms)
-ℹ tests 35
-ℹ suites 0
-ℹ pass 35
-ℹ fail 0
-ℹ cancelled 0
-ℹ skipped 0
-ℹ todo 0
-ℹ duration_ms 366.132458

package/test.js

@@ -1,63 +0,0 @@
-import Client from './exports/peernet.js'
-
-const client = await new Client({
-  network: 'leofcoin:peach',
-  networkVersion: 'peach',
-  stars: ['wss://star.leofcoin.org'],
-  version: '0.1.0'
-})
-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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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,13 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "NodeNext",
-    "target": "ESNext",
-    "declaration": true,
-    "outDir": "./exports",
-    "rootDir": "./src",
-    "moduleResolution": "NodeNext",
-    "allowJs": true,
-    "skipLibCheck": true
-  },
-  "include": ["./src/**/*"]
-}