@leofcoin/peernet 2.0.0 → 3.0.0

package/src/discovery/peer-discovery.js

@@ -1,75 +0,0 @@
-import { protoFor } from './../utils/utils.js'
-
-export default class PeerDiscovery {
-  constructor(id) {
-    this.id = id
-  }
-
-  _getPeerId(id) {
-    if (!peernet.peerMap || (peernet.peerMap && peernet.peerMap.size === 0)) return false
-
-    for (const entry of [...peernet.peerMap.entries()]) {
-      for (const _id of entry[1]) {
-        if (_id === id) return entry[0]
-      }
-    }
-  }
-
-  async discover(peer) {
-    let id = this._getPeerId(peer.id)
-    if (id) return id
-    const data = await new peernet.protos['peernet-peer']({ id: this.id })
-    const node = await peernet.prepareMessage(peer.id, data.encoded)
-
-    let response = await peer.request(node.encoded)
-    response = await protoFor(response)
-    response = await new peernet.protos['peernet-peer-response'](response.decoded.data)
-
-    id = response.decoded.id
-    if (id === this.id) return
-
-    if (!peernet.peerMap.has(id)) peernet.peerMap.set(id, [peer.id])
-    else {
-      const connections = peernet.peerMap.get(id)
-      if (connections.indexOf(peer.id) === -1) {
-        connections.push(peer.id)
-        peernet.peerMap.set(peer.id, connections)
-      }
-    }
-    return id
-  }
-
-  async discoverHandler(message, peer) {
-    const { id, proto } = message
-    // if (typeof message.data === 'string') message.data = Buffer.from(message.data)
-    if (proto.name === 'peernet-peer') {
-      const from = proto.decoded.id
-      if (from === this.id) return
-
-      if (!peernet.peerMap.has(from)) peernet.peerMap.set(from, [peer.id])
-      else {
-        const connections = peernet.peerMap.get(from)
-        if (connections.indexOf(peer.id) === -1) {
-          connections.push(peer.id)
-          peernet.peerMap.set(from, connections)
-        }
-      }
-      const data = await new peernet.protos['peernet-peer-response']({ id: this.id })
-      const node = await peernet.prepareMessage(from, data.encoded)
-
-      peer.write(Buffer.from(JSON.stringify({ id, data: node.encoded })))
-    } else if (proto.name === 'peernet-peer-response') {
-      const from = proto.decoded.id
-      if (from === this.id) return
-
-      if (!peernet.peerMap.has(from)) peernet.peerMap.set(from, [peer.id])
-      else {
-        const connections = peernet.peerMap.get(from)
-        if (connections.indexOf(peer.id) === -1) {
-          connections.push(peer.id)
-          peernet.peerMap.set(from, connections)
-        }
-      }
-    }
-  }
-}

package/src/errors/errors.js

@@ -1,12 +0,0 @@
-export const encapsulatedError = () => {
-  return new Error('Nodes/Data should be send encapsulated by peernet-message')
-}
-
-export const dhtError = (proto) => {
-  const text = `Received proto ${proto.name} expected peernet-dht-response`
-  return new Error(`Routing error: ${text}`)
-}
-
-export const nothingFoundError = (hash) => {
-  return new Error(`nothing found for ${hash}`)
-}

package/src/file-transfer.ts

@@ -1,194 +0,0 @@
-export type FileTransferState = 'idle' | 'running' | 'paused' | 'completed' | 'cancelled' | 'failed'
-
-export type FileTransferProgress = {
-  hash: string
-  state: FileTransferState
-  completedChunks: number
-  totalChunks: number
-  transferredBytes: number
-  totalBytes: number
-}
-
-type ProgressListener = (progress: FileTransferProgress) => void
-
-/** A resumable download. Completed chunks remain cached on the transfer instance. */
-export default class FileTransfer {
-  readonly hash: string
-  state: FileTransferState = 'idle'
-  result: Promise<Uint8Array>
-  error?: unknown
-
-  #fetch: (hash: string, index?: number) => Promise<Uint8Array | undefined>
-  #decode: (data: Uint8Array) => Promise<any>
-  #verify: (data: Uint8Array, hash: string) => Promise<boolean>
-  #pin?: (hash: string, data: Uint8Array) => Promise<any>
-  #verifyManifest: boolean
-  #concurrency: number
-  #stopped = false
-  #listeners = new Set<ProgressListener>()
-  #chunks = new Map<number, Uint8Array>()
-  #resumeWaiters: Array<() => void> = []
-  #resolve!: (value: Uint8Array) => void
-  #reject!: (reason?: unknown) => void
-  #totalChunks = 0
-  #totalBytes = 0
-  #started = false
-
-  constructor(options: {
-    hash: string
-    fetch: (hash: string, index?: number) => Promise<Uint8Array | undefined>
-    decode: (data: Uint8Array) => Promise<any>
-    verify: (data: Uint8Array, hash: string) => Promise<boolean>
-    pin?: (hash: string, data: Uint8Array) => Promise<any>
-    verifyManifest?: boolean
-    concurrency?: number
-  }) {
-    this.hash = options.hash
-    this.#fetch = options.fetch
-    this.#decode = options.decode
-    this.#verify = options.verify
-    this.#pin = options.pin
-    this.#verifyManifest = options.verifyManifest !== false
-    this.#concurrency = options.concurrency ?? 4
-    if (!Number.isSafeInteger(this.#concurrency) || this.#concurrency <= 0)
-      throw new TypeError('concurrency must be a positive integer')
-    this.result = new Promise((resolve, reject) => {
-      this.#resolve = resolve
-      this.#reject = reject
-    })
-  }
-
-  get progress(): FileTransferProgress {
-    let transferredBytes = 0
-    for (const chunk of this.#chunks.values()) transferredBytes += chunk.length
-    return {
-      hash: this.hash,
-      state: this.state,
-      completedChunks: this.#chunks.size,
-      totalChunks: this.#totalChunks,
-      transferredBytes,
-      totalBytes: this.#totalBytes
-    }
-  }
-
-  onProgress(listener: ProgressListener): () => void {
-    this.#listeners.add(listener)
-    listener(this.progress)
-    return () => this.#listeners.delete(listener)
-  }
-
-  start(): this {
-    if (!this.#started) {
-      this.#started = true
-      this.state = 'running'
-      this.#emit()
-      void this.#run()
-    }
-    return this
-  }
-
-  pause(): void {
-    if (this.state === 'running') {
-      this.state = 'paused'
-      this.#emit()
-    }
-  }
-
-  resume(): void {
-    if (this.state !== 'paused') return
-    this.state = 'running'
-    const waiters = this.#resumeWaiters.splice(0)
-    for (const resolve of waiters) resolve()
-    this.#emit()
-  }
-
-  cancel(): void {
-    if (this.state === 'completed' || this.state === 'failed' || this.state === 'cancelled') return
-    this.state = 'cancelled'
-    this.#stopped = true
-    const error = new Error(`Transfer ${this.hash} was cancelled`)
-    this.error = error
-    const waiters = this.#resumeWaiters.splice(0)
-    for (const resolve of waiters) resolve()
-    this.#reject(error)
-    this.#emit()
-  }
-
-  async #waitUntilRunning(): Promise<void> {
-    if (this.state === 'paused') await new Promise<void>((resolve) => this.#resumeWaiters.push(resolve))
-    if (this.state === 'cancelled') throw this.error
-  }
-
-  async #run(): Promise<void> {
-    try {
-      const manifestData = await this.#fetch(this.hash)
-      if (!manifestData) throw new Error(`Unable to download ${this.hash}`)
-      if (this.#verifyManifest && !(await this.#verify(manifestData, this.hash)))
-        throw new Error(`Manifest hash mismatch for ${this.hash}`)
-      const manifest = await this.#decode(manifestData)
-      if (this.#pin) await this.#pin(this.hash, manifestData)
-
-      if (!manifest.chunked) {
-        if (manifest.links?.length) throw new Error(`${this.hash} is a directory`)
-        const content = manifest.content || new Uint8Array()
-        this.#totalChunks = 1
-        this.#totalBytes = content.length
-        this.#chunks.set(0, content)
-        this.state = 'completed'
-        this.#resolve(content)
-        this.#emit()
-        return
-      }
-
-      const links = manifest.links || []
-      this.#totalChunks = links.length
-      this.#totalBytes =
-        Number(manifest.size) || links.reduce((sum: number, link: { size?: number }) => sum + (Number(link.size) || 0), 0)
-      this.#emit()
-
-      let nextIndex = 0
-      const worker = async () => {
-        while (!this.#stopped) {
-          await this.#waitUntilRunning()
-          const index = nextIndex++
-          if (index >= links.length) return
-          if (this.#chunks.has(index)) continue
-          const encoded = await this.#fetch(links[index].hash, index)
-          if (this.#stopped) return
-          if (!encoded) throw new Error(`Missing chunk ${index + 1}/${links.length}`)
-          if (!(await this.#verify(encoded, links[index].hash))) throw new Error(`Hash mismatch for chunk ${index + 1}`)
-          const chunkNode = await this.#decode(encoded)
-          const content = chunkNode.content || new Uint8Array()
-          this.#chunks.set(index, content)
-          if (this.#pin) await this.#pin(links[index].hash, encoded)
-          this.#emit()
-        }
-      }
-      await Promise.all(Array.from({ length: Math.min(this.#concurrency, links.length) }, () => worker()))
-
-      const output = new Uint8Array(this.#totalBytes)
-      let offset = 0
-      for (let index = 0; index < this.#totalChunks; index++) {
-        const chunk = this.#chunks.get(index)
-        if (!chunk) throw new Error(`Missing downloaded chunk ${index + 1}`)
-        output.set(chunk, offset)
-        offset += chunk.length
-      }
-      this.state = 'completed'
-      this.#resolve(offset === output.length ? output : output.slice(0, offset))
-      this.#emit()
-    } catch (error) {
-      if (this.state === 'cancelled') return
-      this.state = 'failed'
-      this.#stopped = true
-      this.error = error
-      this.#reject(error)
-      this.#emit()
-    }
-  }
-
-  #emit(): void {
-    const progress = this.progress
-    for (const listener of this.#listeners) listener(progress)
-  }
-}

package/src/handlers/data.js

@@ -1,15 +0,0 @@
-import { protoFor } from './../utils/utils.js'
-
-const dataHandler = async (message) => {
-  if (!message) return
-
-  try {
-    const { data, id, from, peer } = message
-    const proto = await protoFor(data)
-    peernet._protoHandler({ id, proto }, peernet.connections[from] || peer, from)
-  } catch (error) {
-    console.error(error)
-  }
-}
-
-export default dataHandler

package/src/handlers/message.js

@@ -1,34 +0,0 @@
-export default class MessageHandler {
-  constructor(network) {
-    this.network = network
-  }
-  /**
-   * hash and sign message
-   *
-   * @param {object} message
-   * @param {Buffer} message.from peer id
-   * @param {Buffer} message.to peer id
-   * @param {string} message.data Peernet message
-   * (PeernetMessage excluded) encoded as a string
-   * @return message
-   */
-  async hashAndSignMessage(message) {
-    const hash = await message.peernetHash
-    message.decoded.signature = globalThis.identity.sign(hash.buffer)
-    return message
-  }
-
-  /**
-   * @param {String} from - peer id
-   * @param {String} to - peer id
-   * @param {String|PeernetMessage} data - data encoded message string
-   * or the messageNode itself
-   */
-  async prepareMessage(message) {
-    if (message.keys.includes('signature')) {
-      message = await this.hashAndSignMessage(message)
-    }
-
-    return message
-  }
-}

package/src/identity.ts

@@ -1,172 +0,0 @@
-import MultiWallet from '@leofcoin/multi-wallet'
-import base58 from '@vandeurenglenn/base58'
-import type { base58String } from '@vandeurenglenn/base58'
-import { encrypt, decrypt } from '@leofcoin/identity-utils'
-import QrScanner from 'qr-scanner'
-import qrcode from 'qrcode'
-
-type StoredAccount = [name: string, externalAddress: string, internalAddress: string]
-type AccountWallet = {
-  address: Promise<string>
-  sign: (hash: Uint8Array) => Promise<Uint8Array>
-}
-
-const accountDerivationSchemes = [
-  {
-    name: 'current',
-    accountIndex: (index: number) => index + 1,
-    addressIndex: 1
-  },
-  {
-    name: 'legacy-v1',
-    accountIndex: (index: number) => index,
-    addressIndex: 0
-  }
-] as const
-
-export const resolveAccountWallets = async (
-  wallet: MultiWallet,
-  accounts: StoredAccount[]
-): Promise<Map<string, AccountWallet>> => {
-  for (const scheme of accountDerivationSchemes) {
-    const wallets = new Map<string, AccountWallet>()
-    let matches = true
-
-    for (const [index, [, externalAddress, internalAddress]] of accounts.entries()) {
-      const account = wallet.account(scheme.accountIndex(index))
-      const external = (await account.external(scheme.addressIndex)) as unknown as AccountWallet
-      const internal = (await account.internal(scheme.addressIndex)) as unknown as AccountWallet
-
-      if ((await external.address) !== externalAddress || (await internal.address) !== internalAddress) {
-        matches = false
-        break
-      }
-      wallets.set(externalAddress, external)
-      wallets.set(internalAddress, internal)
-    }
-
-    if (matches) return wallets
-  }
-
-  throw new Error('stored accounts do not match this identity under a supported derivation scheme')
-}
-
-export default class Identity {
-  #wallet: MultiWallet
-  #accountWallets = new Map<string, AccountWallet>()
-  network
-  id: string
-  selectedAccount: string
-
-  constructor(network: string) {
-    this.network = network
-  }
-
-  get accounts(): Promise<[[name: string, externalAddress: string, internalAddress: string]]> {
-    return this.getAccounts()
-  }
-
-  async getAccounts(): Promise<[[name: string, externalAddress: string, internalAddress: string]]> {
-    let accounts = await globalThis.walletStore.get('accounts')
-    accounts = new TextDecoder().decode(accounts)
-    return JSON.parse(accounts)
-  }
-
-  async load(password?: string, fresh = false): Promise<void> {
-    if (password && password.includes('.txt')) {
-      const { readFile } = await import('fs/promises')
-      try {
-        password = (await readFile(password)).toString()
-      } catch (error) {
-        console.error(error)
-      }
-    }
-    if (!password) {
-      // @ts-ignore
-      const importee: { default: () => Promise<string> } = await import('./prompts/password.js')
-      password = await importee.default()
-    }
-
-    // LevelDB opens lazily. Touch both stores before freshIdentity clears them;
-    // clearing a brand-new, unopened store throws LEVEL_DATABASE_NOT_OPEN.
-    const [accountExists] = await Promise.all([
-      globalThis.accountStore.has('public'),
-      globalThis.walletStore.has('identity')
-    ])
-    if (accountExists && !fresh) {
-      const pub = await globalThis.accountStore.get('public')
-      this.id = JSON.parse(new TextDecoder().decode(pub)).walletId
-      const selected = await globalThis.walletStore.get('selected-account')
-      this.selectedAccount = new TextDecoder().decode(selected)
-    } else {
-      const importee = await import(/* webpackChunkName: "generate-account" */ '@leofcoin/generate-account')
-      const { identity, accounts } = await importee.default(password, this.network)
-      if (fresh) {
-        await globalThis.accountStore.clear()
-        await globalThis.walletStore.clear()
-      }
-      await globalThis.accountStore.put('public', JSON.stringify({ walletId: identity.walletId }))
-
-      await globalThis.walletStore.put('version', String(1))
-      await globalThis.walletStore.put('accounts', JSON.stringify(accounts))
-      await globalThis.walletStore.put('selected-account', accounts[0][1])
-      await globalThis.walletStore.put('identity', JSON.stringify(identity))
-
-      this.selectedAccount = accounts[0][1]
-      this.id = identity.walletId
-    }
-    const identity = JSON.parse(new TextDecoder().decode(await globalThis.walletStore.get('identity')))
-    this.#wallet = new MultiWallet(this.network)
-    const multiWIF = await decrypt(password, base58.decode(identity.multiWIF))
-    await this.#wallet.fromMultiWif(multiWIF)
-    await this.#loadAccountWallets()
-  }
-
-  async #loadAccountWallets() {
-    const accounts = await this.getAccounts()
-    this.#accountWallets = await resolveAccountWallets(this.#wallet, accounts)
-    if (!this.#accountWallets.has(this.selectedAccount)) {
-      throw new Error(`selected account ${this.selectedAccount} is not part of this identity`)
-    }
-  }
-
-  selectAccount(account: string) {
-    if (!this.#accountWallets.has(account)) throw new Error(`unknown identity account ${account}`)
-    this.selectedAccount = account
-    return walletStore.put('selected-account', account)
-  }
-
-  sign(hash: Uint8Array) {
-    const wallet = this.#accountWallets.get(this.selectedAccount)
-    if (!wallet) throw new Error(`no signer available for selected account ${this.selectedAccount}`)
-    return wallet.sign(hash.subarray(0, 32))
-  }
-
-  lock(password: string) {
-    this.#wallet.lock(password)
-  }
-
-  unlock(password: string) {
-    this.#wallet.unlock(password)
-  }
-
-  async export(password: string) {
-    return this.#wallet.export(password)
-  }
-
-  async import(password, encrypted: base58String) {
-    await this.#wallet.import(password, encrypted)
-  }
-
-  async exportQR(password: string) {
-    const exported = await this.export(password)
-    return globalThis.navigator
-      ? await qrcode.toDataURL(exported)
-      : await qrcode.toString(exported, { type: 'terminal' })
-  }
-
-  async importQR(image: File | Blob, password: string) {
-    const multiWIF = await QrScanner.default.scanImage(image)
-    return this.import(password, multiWIF)
-  }
-}

package/src/messages/chat.ts

@@ -1,13 +0,0 @@
-import proto from './../proto/chat-message.proto.js'
-import { FormatInterface } from '@leofcoin/codec-format-interface'
-
-export default class ChatMessage extends FormatInterface {
-  get messageName(): string {
-    return 'ChatMessage'
-  }
-
-  constructor(buffer: any) {
-    const name = 'chat-message'
-    super(buffer, proto, { name })
-  }
-}

package/src/messages/data-response.ts

@@ -1,13 +0,0 @@
-import proto from './../proto/data-response.proto.js'
-import { FormatInterface } from '@leofcoin/codec-format-interface'
-
-export default class DataMessageResponse extends FormatInterface {
-  get messageName(): string {
-    return 'PeernetDataMessageResponse'
-  }
-
-  constructor(data: any) {
-    const name = 'peernet-data-response'
-    super(data, proto, { name })
-  }
-}

package/src/messages/data.ts

@@ -1,17 +0,0 @@
-import proto from './../proto/data.proto.js'
-import { FormatInterface } from '@leofcoin/codec-format-interface'
-
-/**
- * @extends {CodecFormat}
- */
-export default class DataMessage extends FormatInterface {
-  get messageName(): string {
-    return 'PeernetDataMessage'
-  }
-  /**
-   * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
-   */
-  constructor(data: any) {
-    super(data, proto, { name: 'peernet-data' })
-  }
-}

package/src/messages/dht-response.ts

@@ -1,13 +0,0 @@
-import proto from './../proto/dht-response.proto.js'
-import { FormatInterface } from '@leofcoin/codec-format-interface'
-
-export default class DHTMessageResponse extends FormatInterface {
-  get messageName(): string {
-    return 'PeernetDHTMessageResponse'
-  }
-
-  constructor(data: any) {
-    const name = 'peernet-dht-response'
-    super(data, proto, { name })
-  }
-}

package/src/messages/dht.ts

@@ -1,21 +0,0 @@
-import proto from './../proto/dht.proto.js'
-import { FormatInterface } from '@leofcoin/codec-format-interface'
-
-/**
- * @example `
-   new DHTMessage(hash, store)
-   // store = optional if not set, peernet checks every store
-   let message = new DHTMessage('hashmvbs124xcfd...', 'transaction')
-   message = new DHTMessage('hashmvbs124xcfd...', 'block')
- `
- */
-export default class DHTMessage extends FormatInterface {
-  get messageName(): string {
-    return 'PeernetDHTMessage'
-  }
-
-  constructor(data: any) {
-    const name = 'peernet-dht'
-    super(data, proto, { name })
-  }
-}

package/src/messages/file-link.ts

@@ -1,17 +0,0 @@
-import proto from '../proto/file-link.proto.js'
-import { FormatInterface } from '@leofcoin/codec-format-interface'
-
-/**
- * @extends {CodecFormat}
- */
-export default class PeernetFileLink extends FormatInterface {
-  get messageName(): string {
-    return 'PeernetFileLink'
-  }
-  /**
-   * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
-   */
-  constructor(data: any) {
-    super(data, proto, { name: 'peernet-file-link' })
-  }
-}

package/src/messages/file.ts

@@ -1,17 +0,0 @@
-import proto from './../proto/file.proto.js'
-import { FormatInterface } from '@leofcoin/codec-format-interface'
-
-/**
- * @extends {CodecFormat}
- */
-export default class PeernetFile extends FormatInterface {
-  get messageName(): string {
-    return 'PeernetFile'
-  }
-  /**
-   * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
-   */
-  constructor(data: any) {
-    super(data, proto, { name: 'peernet-file' })
-  }
-}

package/src/messages/peer-response.ts

@@ -1,13 +0,0 @@
-import proto from '../proto/peer-response.proto.js'
-import { FormatInterface } from '@leofcoin/codec-format-interface'
-
-export default class PeerMessageResponse extends FormatInterface {
-  get messageName(): string {
-    return 'PeernetPeerMessageResponse'
-  }
-
-  constructor(data: any) {
-    const name = 'peernet-peer-response'
-    super(data, proto, { name })
-  }
-}

package/src/messages/peer.ts

@@ -1,13 +0,0 @@
-import proto from '../proto/peer.proto.js'
-import { FormatInterface } from '@leofcoin/codec-format-interface'
-
-export default class PeerMessage extends FormatInterface {
-  get messageName(): string {
-    return 'PeernetPeerMessage'
-  }
-
-  constructor(data: any) {
-    const name = 'peernet-peer'
-    super(data, proto, { name })
-  }
-}

package/src/messages/peernet.ts

@@ -1,13 +0,0 @@
-import proto from './../proto/peernet.proto.js'
-import { FormatInterface } from '@leofcoin/codec-format-interface'
-
-export default class PeernetMessage extends FormatInterface {
-  get messageName(): string {
-    return 'PeernetMessage'
-  }
-
-  constructor(buffer: any) {
-    const name = 'peernet-message'
-    super(buffer, proto, { name })
-  }
-}

package/src/messages/ps.ts

@@ -1,13 +0,0 @@
-import proto from './../proto/ps.proto.js'
-import { FormatInterface } from '@leofcoin/codec-format-interface'
-
-export default class PsMessage extends FormatInterface {
-  get messageName(): string {
-    return 'PsMessage'
-  }
-
-  constructor(buffer: any) {
-    const name = 'peernet-ps'
-    super(buffer, proto, { name })
-  }
-}