@leofcoin/peernet 0.18.8 → 1.0.0

package/exports/store.js

@@ -1,229 +1,227 @@
 import { join } from 'path';
-import { homedir, platform } from 'os';
+import { homedir } from 'os';
 import { readdirSync } from 'fs';
-import { execSync } from 'child_process';
+import { mkdirp } from 'mkdirp';
 import { ClassicLevel } from 'classic-level';
 
-// import base32 from '@vandeurenglenn/base32'
-// import base58 from '@vandeurenglenn/base58'
-
-// export const encodings = {
-//   base58,
-//   base32
-// }
-
-const encode$1 = (string, encoding = 'utf-8') => {
-  if (typeof string === 'string') {
-    let encoded;
-    
-    // if (encodings[encoding]) encoded = encodings[encoding].encode(encoded)    
-    encoded = new TextEncoder().encode(string);
-    return encoded
-  }
-  throw Error(`expected typeof String instead got ${string}`)
-};
-
-const decode$1 = (uint8Array, encoding) => {
-  if (uint8Array instanceof Uint8Array) {
-    let decoded;
-    // if (encodings[encoding]) decoded = encodings[encoding].decode(decoded)
-    decoded = new TextDecoder().decode(uint8Array);
-    
-    return decoded
-  }
-  throw Error(`expected typeof uint8Array instead got ${uint8Array}`)
+// import base32 from '@vandeurenglenn/base32'
+// import base58 from '@vandeurenglenn/base58'
+
+// export const encodings = {
+//   base58,
+//   base32
+// }
+
+const encode$1 = (string, encoding = 'utf-8') => {
+  if (typeof string === 'string') {
+    let encoded;
+    
+    // if (encodings[encoding]) encoded = encodings[encoding].encode(encoded)    
+    encoded = new TextEncoder().encode(string);
+    return encoded
+  }
+  throw Error(`expected typeof String instead got ${string}`)
+};
+
+const decode$1 = (uint8Array, encoding) => {
+  if (uint8Array instanceof Uint8Array) {
+    let decoded;
+    // if (encodings[encoding]) decoded = encodings[encoding].decode(decoded)
+    decoded = new TextDecoder().decode(uint8Array);
+    
+    return decoded
+  }
+  throw Error(`expected typeof uint8Array instead got ${uint8Array}`)
 };
 
-class KeyValue {
-
-  /**
-   * @param {string | Uint8Array} input
-   */
-  constructor(input) {
-    if (typeof input === 'string') {
-      this.uint8Array = encode$1(input);
-    } else if (input instanceof Uint8Array) {
-      this.uint8Array = input;
-    } else if (input instanceof KeyValue) {
-      this.uint8Array = input.uint8Array;
-    } else {
-      throw new Error('Invalid KeyValue, should be a String, Uint8Array or KeyValue')
-    }
-  }
-
-  isKeyValue() {
-    return true
-  }
-
-  /**
-   * Convert to the string representation
-   *
-   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding='utf8'] - The encoding to use.
-   * @returns {string}
-   */
-  toString(encoding = 'utf8') {
-    return decode$1(this.uint8Array)
-  }
-
+class KeyValue {
+
+  /**
+   * @param {string | Uint8Array} input
+   */
+  constructor(input) {
+    if (typeof input === 'string') {
+      this.uint8Array = encode$1(input);
+    } else if (input instanceof Uint8Array) {
+      this.uint8Array = input;
+    } else if (input instanceof KeyValue) {
+      this.uint8Array = input.uint8Array;
+    } else {
+      throw new Error('Invalid KeyValue, should be a String, Uint8Array or KeyValue')
+    }
+  }
+
+  isKeyValue() {
+    return true
+  }
+
+  /**
+   * Convert to the string representation
+   *
+   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding='utf8'] - The encoding to use.
+   * @returns {string}
+   */
+  toString(encoding = 'utf8') {
+    return decode$1(this.uint8Array)
+  }
+
 }
 
-const mkdirp = path => execSync(`mkdir "${platform() === 'win32' ? path.replace(/\//g, '\\') : path}"`);
-
-const init = (root, home = true) => {
-  let _root;
-  if (home) _root = join(homedir(), root);
-    if (readdirSync) try {
-      readdirSync(_root);
-    } catch (e) {
-      mkdirp(_root);
-    }
-
-    return _root
+const init = (root, home = true) => {
+  let _root = root;
+  if (home) _root = join(homedir(), root);
+  if (readdirSync) try {
+    readdirSync(_root);
+  } catch (e) {
+    mkdirp(_root);
+  }
+
+  return _root
 };
 
-// import base32 from '@vandeurenglenn/base32'
-// import base58 from '@vandeurenglenn/base58'
-
-// export const encodings = {
-//   base58,
-//   base32
-// }
-
-const encode = (string, encoding = 'utf-8') => {
-  if (typeof string === 'string') {
-    let encoded;
-    
-    // if (encodings[encoding]) encoded = encodings[encoding].encode(encoded)    
-    encoded = new TextEncoder().encode(string);
-    return encoded
-  }
-  throw Error(`expected typeof String instead got ${string}`)
-};
-
-const decode = (uint8Array, encoding) => {
-  if (uint8Array instanceof Uint8Array) {
-    let decoded;
-    // if (encodings[encoding]) decoded = encodings[encoding].decode(decoded)
-    decoded = new TextDecoder().decode(uint8Array);
-    
-    return decoded
-  }
-  throw Error(`expected typeof uint8Array instead got ${uint8Array}`)
+// import base32 from '@vandeurenglenn/base32'
+// import base58 from '@vandeurenglenn/base58'
+
+// export const encodings = {
+//   base58,
+//   base32
+// }
+
+const encode = (string, encoding = 'utf-8') => {
+  if (typeof string === 'string') {
+    let encoded;
+    
+    // if (encodings[encoding]) encoded = encodings[encoding].encode(encoded)    
+    encoded = new TextEncoder().encode(string);
+    return encoded
+  }
+  throw Error(`expected typeof String instead got ${string}`)
 };
 
-const pathSepS = '/';
-class KeyPath {
-
-  /**
-   * @param {string | Uint8Array} input
-   */
-  constructor(input) {
-    if (typeof input === 'string') {
-      this.uint8Array = encode(input);
-    } else if (input instanceof Uint8Array) {
-      this.uint8Array = input;
-    } else if (input instanceof KeyPath) {
-      this.uint8Array = input.uint8Array;
-    } else {
-      throw new Error('Invalid keyPath, should be a String, Uint8Array or KeyPath')
-    }
-  }
-  
-  isKeyPath() {
-    return true
-  }
-
-  /**
-   * Convert to the string representation
-   *
-   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding='utf8'] - The encoding to use.
-   * @returns {string}
-   */
-  toString(encoding = 'hex') {
-    return decode(this.uint8Array)
-  }
-
-  /**
-   * Returns the `list` representation of this path.
-   *
-   * @returns string[]
-   *
-   * @example
-   * ```js
-   * new Key('/Comedy/MontyPython/Actor:JohnCleese').list()
-   * // => ['Comedy', 'MontyPythong', 'Actor:JohnCleese']
-   * ```
-   */
-  list() {
-    return this.toString().split(pathSepS).slice(1)
-  }
-
+const decode = (uint8Array, encoding) => {
+  if (uint8Array instanceof Uint8Array) {
+    let decoded;
+    // if (encodings[encoding]) decoded = encodings[encoding].decode(decoded)
+    decoded = new TextDecoder().decode(uint8Array);
+    
+    return decoded
+  }
+  throw Error(`expected typeof uint8Array instead got ${uint8Array}`)
+};
+
+const pathSepS = '/';
+class KeyPath {
+
+  /**
+   * @param {string | Uint8Array} input
+   */
+  constructor(input) {
+    if (typeof input === 'string') {
+      this.uint8Array = encode(input);
+    } else if (input instanceof Uint8Array) {
+      this.uint8Array = input;
+    } else if (input instanceof KeyPath) {
+      this.uint8Array = input.uint8Array;
+    } else {
+      throw new Error('Invalid keyPath, should be a String, Uint8Array or KeyPath')
+    }
+  }
+  
+  isKeyPath() {
+    return true
+  }
+
+  /**
+   * Convert to the string representation
+   *
+   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding='utf8'] - The encoding to use.
+   * @returns {string}
+   */
+  toString(encoding = 'hex') {
+    return decode(this.uint8Array)
+  }
+
+  /**
+   * Returns the `list` representation of this path.
+   *
+   * @returns string[]
+   *
+   * @example
+   * ```js
+   * new Key('/Comedy/MontyPython/Actor:JohnCleese').list()
+   * // => ['Comedy', 'MontyPythong', 'Actor:JohnCleese']
+   * ```
+   */
+  list() {
+    return this.toString().split(pathSepS).slice(1)
+  }
+
 }
 
-class Store {
-  constructor(name = 'storage', root, version = 'v1.0.0') {
-    this.name = name;
-    this.root = init(root);
-    this.version = version;
-
-    this.db = new ClassicLevel(join(this.root, this.name), { valueEncoding: 'view'});
-  }
-
-  toKeyPath(key) {
-    if (!key.isKeyPath()) key = new KeyPath(key);
-    return key.toString('base32')
-  }
-  
-  toKeyValue(value) {
-    if (!value.isKeyValue()) value = new KeyValue(value);
-    return value.uint8Array
-  }
-
-  toUint8Array(buffer) {
-    return Buffer.isBuffer(buffer) ? new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / Uint8Array.BYTES_PER_ELEMENT) : buffer
-  }
-
-  async get(key) {
-    return this.toUint8Array(await this.db.get(this.toKeyPath(key))) 
-  }
-
-  async put(key, value) {
-    return this.db.put(this.toKeyPath(key), this.toKeyValue(value))
-  }
-
-  async delete(key) {
-    return this.db.del(this.toKeyPath(key))
-  }
-
-  async clear() {
-    return this.db.clear()
-  }
-
-  async values(limit = -1) {
-    const values = [];
-    for await (const value of this.db.values({limit})) {
-      values.push(this.toUint8Array(value));
-    }
-    return values
-  }
-
-  async keys(limit = -1) {
-    const keys = [];
-    for await (const key of this.db.keys({limit})) {
-      keys.push(key);
-    }
-    return keys
-  }
-
-    /**
-     * 
-     * @param {object} options {  limit, gt, lt, reverse }
-     * @returns 
-     */
-  iterate(options) {
-    return this.db.iterator(options)
-  }
-
+class Store {
+  constructor(name = 'storage', root, version = 'v1.0.0') {
+    this.name = name;
+    this.root = init(root);
+    this.version = version;
+
+    this.db = new ClassicLevel(join(this.root, this.name), { valueEncoding: 'view'});
+  }
+
+  toKeyPath(key) {
+    if (!key.isKeyPath()) key = new KeyPath(key);
+    return key.toString()
+  }
+  
+  toKeyValue(value) {
+    if (!value.isKeyValue()) value = new KeyValue(value);
+    return value.uint8Array
+  }
+
+  toUint8Array(buffer) {
+    return Buffer.isBuffer(buffer) ? new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / Uint8Array.BYTES_PER_ELEMENT) : buffer
+  }
+
+  async get(key) {
+    return this.toUint8Array(await this.db.get(this.toKeyPath(key))) 
+  }
+
+  async put(key, value) {
+    return this.db.put(this.toKeyPath(key), this.toKeyValue(value))
+  }
+
+  async delete(key) {
+    return this.db.del(this.toKeyPath(key))
+  }
+
+  async clear() {
+    return this.db.clear()
+  }
+
+  async values(limit = -1) {
+    const values = [];
+    for await (const value of this.db.values({limit})) {
+      values.push(this.toUint8Array(value));
+    }
+    return values
+  }
+
+  async keys(limit = -1) {
+    const keys = [];
+    for await (const key of this.db.keys({limit})) {
+      keys.push(key);
+    }
+    return keys
+  }
+
+    /**
+     * 
+     * @param {object} options {  limit, gt, lt, reverse }
+     * @returns 
+     */
+  iterate(options) {
+    return this.db.iterator(options)
+  }
+
 }
 
 export { Store as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "0.18.8",
+  "version": "1.0.0",
   "description": "",
   "main": "src/peernet.js",
   "exports": {
@@ -26,7 +26,7 @@
   "dependencies": {
     "@leofcoin/codec-format-interface": "^1.6.0",
     "@leofcoin/codecs": "^1.0.0",
-    "@leofcoin/generate-account": "^1.2.0",
+    "@leofcoin/generate-account": "^2.0.0",
     "@leofcoin/multi-wallet": "^3.0.1",
     "@leofcoin/peernet-swarm": "^0.5.0",
     "@leofcoin/storage": "^3.0.0",
@@ -36,6 +36,7 @@
     "@vandeurenglenn/debug": "^1.0.0",
     "@vandeurenglenn/is-hex": "^1.0.0",
     "@vandeurenglenn/little-pubsub": "^1.3.1",
+    "inquirer": "^9.1.4",
     "multi-signature": "^1.3.1",
     "socket-request-client": "^1.5.0",
     "socket-request-server": "^1.5.0"

package/rollup.config.js

@@ -10,7 +10,7 @@ rimraf.sync('./exports/**')
 
 
 export default [{
-  input: ['./src/peernet.ts', './node_modules/@leofcoin/storage/exports/browser-store.js'],
+  input: ['./src/peernet.ts', './src/prompts/password/browser.js', './node_modules/@leofcoin/storage/exports/browser-store.js'],
   output: {
     format: 'es',
     dir: './exports/browser'
@@ -23,14 +23,20 @@ export default [{
       mainFields: ["browser", "module", "main"]
     }),
     typescript({...tsconfig, outDir: './exports/browser'})
+  ],
+  external: [
+    './prompts/password/node.js'
   ]
 }, {
-  input: ['./src/peernet.ts', './node_modules/@leofcoin/storage/exports/store.js'],
+  input: ['./src/peernet.ts', './src/prompts/password/node.js', './node_modules/@leofcoin/storage/exports/store.js'],
   output: {
     format: 'es',
     dir: './exports'
   },
   plugins: [
     typescript({...tsconfig, outDir: './exports'})
+  ],
+  external: [
+    './prompts/password/browser.js'
   ]
 }]

package/src/handlers/message.js

@@ -13,15 +13,8 @@ export default class MessageHandler {
    * @return message
    */
   async hashAndSignMessage(message) {
-    let identity = await walletStore.get('identity')
-    identity = JSON.parse(identity)
-    if (!globalThis.MultiWallet) {
-      const importee = await import(/* webpackChunkName: "multi-wallet" */ '@leofcoin/multi-wallet')
-      globalThis.MultiWallet = importee.default
-    }
-    const wallet = new MultiWallet(this.network)
-    wallet.recover(identity.mnemonic)
-    message.decoded.signature = wallet.sign(Buffer.from(await message.hash).slice(0, 32))
+    const hash = await message.peernetHash
+    message.decoded.signature = globalThis.identity.sign(hash.buffer)
     return message
   }
 

package/src/identity.ts

@@ -0,0 +1,93 @@
+import MultiWallet from '@leofcoin/multi-wallet'
+
+const walletStore = globalThis.walletStore
+const accountStore = globalThis.accountStore
+
+export default class Identity {
+  #wallet: MultiWallet
+  network: MultiWallet.network
+  id: 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 walletStore.get('accounts')
+    accounts = new TextDecoder().decode(accounts)
+    return JSON.parse(accounts)
+  }
+
+  async load(password?: string): Promise<void> {
+    let importee: { default: () => Promise<string> }
+    if (!password) {
+      if (globalThis.navigator) importee = await import('./prompts/password/browser.js')
+      else {
+        const path = await import('node:path');
+        const { fileURLToPath } = await import('node:url');
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const url = path.join(__dirname, './prompts/password/node.js')
+        importee = await import(url)      
+      }
+      password = await importee.default()
+    }
+    
+    const accountExists = await accountStore.has('public')
+    if (accountExists) {
+      const pub = await accountStore.get('public')
+      this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
+      const selected = await walletStore.get('selected-account')
+      globalThis.peernet.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)
+      await accountStore.put('public', JSON.stringify({walletId: identity.walletId}));
+      
+      await walletStore.put('version', String(1))
+      await walletStore.put('accounts', JSON.stringify(accounts))
+      await walletStore.put('selected-account', accounts[0][1])
+      await walletStore.put('identity', JSON.stringify(identity))
+
+      globalThis.peernet.selectedAccount = accounts[0][1]
+      this.id = identity.walletId
+    }
+    const identity = JSON.parse(new TextDecoder().decode(await walletStore.get('identity')))
+    this.#wallet = new MultiWallet(this.network)
+    await this.#wallet.recover(identity.mnemonic, password, this.network)
+  }
+
+  sign(hash: Uint8Array) {
+    return this.#wallet.sign(hash.subarray(0, 32))
+  }
+
+  async export(password: string) {
+    if (!password) throw new Error('IdentityExportError: password required')
+    const identity = JSON.parse(new TextDecoder().decode(await walletStore.get('identity')))
+    this.#wallet = new MultiWallet(this.network)
+    await this.#wallet.recover(identity.mnemonic, password, this.network)
+    return this.#wallet.toMultiWif()
+  }
+
+  async import(multiWIF: string) {
+    this.#wallet = new MultiWallet(this.network)
+    await this.#wallet.fromMultiWif(multiWIF)
+  }
+
+  async unlock({ key, iv, cipher }) {
+
+  }
+
+  /**
+   * Lock current wallet or import wallet using a MultiWIF and lock
+   * 
+   * @param password 
+   * @param multiWIF 
+   */
+  async lock(password: string, multiWIF?: string) {
+  }
+}