@leofcoin/peernet 0.18.7 → 1.0.0

package/exports/browser/peernet.js

@@ -1,2 +1,2 @@
-export { P as default } from './peernet-29c659a0.js';
-import './value-40634404.js';
+export { P as default } from './peernet-1908438f.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/{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/node.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 };

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$1 from '@leofcoin/multi-wallet';
 
 const BufferToUint8Array = data => {
     if (data.type === 'Buffer') {
@@ -272,7 +273,8 @@ class MessageHandler {
         }
         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.hash();
+        message.decoded.signature = wallet.sign(hash.subarray(0, 32));
         return message;
     }
     /**
@@ -305,6 +307,84 @@ const nothingFoundError = (hash) => {
     return new Error(`nothing found for ${hash}`);
 };
 
+const walletStore$1 = globalThis.walletStore;
+const accountStore = globalThis.accountStore;
+class Identity {
+    #wallet;
+    network;
+    id;
+    constructor(network) {
+        this.network = network;
+    }
+    get accounts() {
+        return this.getAccounts();
+    }
+    async getAccounts() {
+        let accounts = await walletStore$1.get('accounts');
+        accounts = new TextDecoder().decode(accounts);
+        return JSON.parse(accounts);
+    }
+    async load(password) {
+        let importee;
+        if (!password) {
+            if (globalThis.navigator)
+                importee = await import('./src/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$1.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$1.put('version', String(1));
+            await walletStore$1.put('accounts', JSON.stringify(accounts));
+            await walletStore$1.put('selected-account', accounts[0][1]);
+            await walletStore$1.put('identity', JSON.stringify(identity));
+            globalThis.peernet.selectedAccount = accounts[0][1];
+            this.id = identity.walletId;
+        }
+        const identity = JSON.parse(new TextDecoder().decode(await walletStore$1.get('identity')));
+        this.#wallet = new MultiWallet$1(this.network);
+        await this.#wallet.recover(identity.mnemonic, password, this.network);
+    }
+    async export(password) {
+        if (!password)
+            throw new Error('IdentityExportError: password required');
+        const identity = JSON.parse(new TextDecoder().decode(await walletStore$1.get('identity')));
+        this.#wallet = new MultiWallet$1(this.network);
+        await this.#wallet.recover(identity.mnemonic, password, this.network);
+        return this.#wallet.toMultiWif();
+    }
+    async import(multiWIF) {
+        this.#wallet = new MultiWallet$1(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 +395,7 @@ globalThis.globalSub = globalThis.globalSub || new PubSub(true);
  * const peernet = new Peernet();
  */
 class Peernet {
+    identity;
     stores = [];
     /**
      * @type {Object}
@@ -362,6 +443,12 @@ class Peernet {
         };
         return this._init(options);
     }
+    get id() {
+        return this.identity.id;
+    }
+    get accounts() {
+        return this.identity.accounts;
+    }
     get defaultStores() {
         return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message'];
     }
@@ -456,36 +543,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();
         this._peerHandler = new PeerDiscovery(this.id);
         this.peerId = this.id;
         pubsub.subscribe('peer:connected', async (peer) => {
@@ -580,7 +639,7 @@ class Peernet {
                 this.handleDHT(peer, id, proto);
                 break;
             }
-            case 'peenet-data': {
+            case 'peernet-data': {
                 this.handleData(peer, id, proto);
                 break;
             }
@@ -718,7 +777,6 @@ class Peernet {
                 if (closest[0])
                     data = await closest[0].request(node.encoded);
             }
-            data = new Uint8Array(Object.values(data));
             const proto = await protoFor(data);
             // TODO: store data automaticly or not
             return BufferToUint8Array(proto.decoded.data);

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;