@leofcoin/peernet 0.18.8 → 1.0.1

package/exports/browser/peernet.js

@@ -1,2 +1,2 @@
-export { P as default } from './peernet-34ea081d.js';
-import './value-40634404.js';
+export { P as default } from './peernet-e74b2091.js';
+import './value-157ab062.js';

package/exports/browser/prompts/password/browser.d.ts

@@ -0,0 +1,2 @@
+declare function _default(): Promise<string>;
+export default _default;

package/exports/browser/prompts/password/node.d.ts

@@ -0,0 +1,2 @@
+declare function _default(): Promise<any>;
+export default _default;

package/exports/browser/prompts/password.js

@@ -0,0 +1,3 @@
+var browser = async () => prompt('enter password');
+
+export { browser as default };

package/exports/browser/{value-40634404.js → value-157ab062.js}

@@ -1,64 +1,64 @@
-// 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 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}`)
 };
 
-class KeyValue {
-
-  /**
-   * @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 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(this.uint8Array)
-  }
-
+class KeyValue {
+
+  /**
+   * @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 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(this.uint8Array)
+  }
+
 }
 
 export { KeyValue as K };

package/exports/peernet.js

@@ -3,6 +3,7 @@ import PubSub from '@vandeurenglenn/little-pubsub';
 import { Codec } from '@leofcoin/codec-format-interface';
 import LeofcoinStorage from '@leofcoin/storage';
 import { utils } from '@leofcoin/codecs';
+import MultiWallet from '@leofcoin/multi-wallet';
 
 const BufferToUint8Array = data => {
     if (data.type === 'Buffer') {
@@ -264,15 +265,8 @@ 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;
     }
     /**
@@ -305,6 +299,75 @@ const nothingFoundError = (hash) => {
     return new Error(`nothing found for ${hash}`);
 };
 
+class Identity {
+    #wallet;
+    network;
+    id;
+    constructor(network) {
+        this.network = network;
+    }
+    get accounts() {
+        return this.getAccounts();
+    }
+    async getAccounts() {
+        let accounts = await globalThis.walletStore.get('accounts');
+        accounts = new TextDecoder().decode(accounts);
+        return JSON.parse(accounts);
+    }
+    async load(password) {
+        if (!password) {
+            const importee = await import('./src/prompts/password.js');
+            password = await importee.default();
+        }
+        const accountExists = await globalThis.accountStore.has('public');
+        if (accountExists) {
+            const pub = await globalThis.accountStore.get('public');
+            this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
+            const selected = await globalThis.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 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));
+            globalThis.peernet.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);
+        await this.#wallet.recover(identity.mnemonic, password, this.network);
+    }
+    sign(hash) {
+        return this.#wallet.sign(hash.subarray(0, 32));
+    }
+    async export(password) {
+        if (!password)
+            throw new Error('IdentityExportError: password required');
+        const identity = JSON.parse(new TextDecoder().decode(await globalThis.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) {
+        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, multiWIF) {
+    }
+}
+
 globalThis.LeofcoinStorage = LeofcoinStorage;
 globalThis.leofcoin = globalThis.leofcoin || {};
 globalThis.pubsub = globalThis.pubsub || new PubSub();
@@ -315,6 +378,7 @@ globalThis.globalSub = globalThis.globalSub || new PubSub(true);
  * const peernet = new Peernet();
  */
 class Peernet {
+    identity;
     stores = [];
     /**
      * @type {Object}
@@ -340,7 +404,7 @@ class Peernet {
      * @example
      * const peernet = new Peernet({network: 'leofcoin', root: '.leofcoin'});
      */
-    constructor(options) {
+    constructor(options, password) {
         /**
          * @property {String} network - current network
          */
@@ -360,7 +424,13 @@ class Peernet {
             up: 0,
             down: 0,
         };
-        return this._init(options);
+        return this._init(options, password);
+    }
+    get id() {
+        return this.identity.id;
+    }
+    get accounts() {
+        return this.identity.accounts;
     }
     get defaultStores() {
         return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message'];
@@ -420,7 +490,7 @@ class Peernet {
      *
      * @return {Promise} instance of Peernet
      */
-    async _init(options) {
+    async _init(options, password) {
         this.requestProtos = {};
         this.storePrefix = options.storePrefix;
         this.root = options.root;
@@ -456,36 +526,8 @@ class Peernet {
         for (const store of this.defaultStores) {
             await this.addStore(store, options.storePrefix, options.root);
         }
-        const accountExists = await accountStore.has('public');
-        if (accountExists) {
-            const pub = await accountStore.get('public');
-            this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
-            let accounts = await walletStore.get('accounts');
-            accounts = new TextDecoder().decode(accounts);
-            const selected = await walletStore.get('selected-account');
-            globalThis.peernet.selectedAccount = new TextDecoder().decode(selected);
-            // fixing account issue (string while needs to be a JSON)
-            // TODO: remove when on mainnet
-            try {
-                this.accounts = JSON.parse(accounts);
-            }
-            catch {
-                this.accounts = [accounts.split(',')];
-            }
-        }
-        else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ '@leofcoin/generate-account');
-            const generateAccount = importee.default;
-            const { identity, accounts, config } = await generateAccount(this.network);
-            // await accountStore.put('config', JSON.stringify(config));
-            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;
-        }
+        this.identity = new Identity(this.network);
+        await this.identity.load(password);
         this._peerHandler = new PeerDiscovery(this.id);
         this.peerId = this.id;
         pubsub.subscribe('peer:connected', async (peer) => {

package/exports/prompts/password/browser.d.ts

@@ -0,0 +1,2 @@
+declare function _default(): Promise<string>;
+export default _default;

package/exports/prompts/password/node.d.ts

@@ -0,0 +1,2 @@
+declare function _default(): Promise<any>;
+export default _default;

package/exports/prompts/password.js

@@ -0,0 +1,8 @@
+import inquirer from 'inquirer';
+
+var node = async () => {
+  const answers = await inquirer.prompt({type: 'password', name: 'password', message: 'Enter password'});
+  return answers.password
+};
+
+export { node as default };