@leofcoin/peernet 0.18.8 → 1.0.0

package/exports/browser/browser-store.js

@@ -1,4 +1,4 @@
-import { K as KeyValue } from './value-40634404.js';
+import { K as KeyValue } from './value-157ab062.js';
 
 const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
 
@@ -315,149 +315,149 @@ replaceTraps((oldTraps) => ({
     },
 }));
 
-// 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}`)
 };
 
-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 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 = '.leofcoin', version = 1) {
-    this.version = version;
-    this.name = name;
-    this.root = root;
-    this.db = openDB(`${root}/${name}`, version, {
-      upgrade(db) {
-        db.createObjectStore(name);
-      }
-    });
-  }
-
-  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
-  }
-
-  async get(key) {
-    return (await this.db).get(this.name, this.toKeyPath(key))
-  }
-
-  async put(key, value) {
-    return (await this.db).put(this.name, this.toKeyValue(value), this.toKeyPath(key))
-  }
-
-  async delete(key) {
-    return (await this.db).delete(this.name, this.toKeyPath(key))
-  }
-
-  async clear() {
-    return (await this.db).clear(this.name)
-  }
-
-  async values(limit = -1) {
-    const values = [];
-    const tx = (await this.db).transaction(this.name);
-    
-    for await (const cursor of tx.store) {
-      values.push(cursor.value);
-      if (limit && values.length === limit) return values      
-    }
-    return values
-  }
-
-  async keys(limit = -1) {
-    const keys = [];
-    const tx = (await this.db).transaction(this.name);
-
-    for await (const cursor of tx.store) {
-      keys.push(cursor.key);
-      if (limit && keys.length === limit) return keys      
-    }
-    return keys
-  }
-
-  async iterate() {
-    return (await this.db).transaction(this.name).store
-  }
-
+class BrowerStore {
+  constructor(name = 'storage', root = '.leofcoin', version = 1) {
+    this.version = version;
+    this.name = name;
+    this.root = root;
+    this.db = openDB(`${root}/${name}`, version, {
+      upgrade(db) {
+        db.createObjectStore(name);
+      }
+    });
+  }
+
+  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
+  }
+
+  async get(key) {
+    return (await this.db).get(this.name, this.toKeyPath(key))
+  }
+
+  async put(key, value) {
+    return (await this.db).put(this.name, this.toKeyValue(value), this.toKeyPath(key))
+  }
+
+  async delete(key) {
+    return (await this.db).delete(this.name, this.toKeyPath(key))
+  }
+
+  async clear() {
+    return (await this.db).clear(this.name)
+  }
+
+  async values(limit = -1) {
+    const values = [];
+    const tx = (await this.db).transaction(this.name);
+    
+    for await (const cursor of tx.store) {
+      values.push(cursor.value);
+      if (limit && values.length === limit) return values      
+    }
+    return values
+  }
+
+  async keys(limit = -1) {
+    const keys = [];
+    const tx = (await this.db).transaction(this.name);
+
+    for await (const cursor of tx.store) {
+      keys.push(cursor.key);
+      if (limit && keys.length === limit) return keys      
+    }
+    return keys
+  }
+
+  async iterate() {
+    return (await this.db).transaction(this.name).store
+  }
+
 }
 
-export { Store as default };
+export { BrowerStore as default };

package/exports/browser/browser.js

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

package/exports/browser/{client-ae251a9c.js → client-94d84d27.js}

@@ -1,5 +1,5 @@
-import { L as LittlePubSub } from './peernet-34ea081d.js';
-import './value-40634404.js';
+import { L as LittlePubSub } from './peernet-1908438f.js';
+import './value-157ab062.js';
 
 var clientApi = _pubsub => {
 

package/exports/browser/{index-72471f52.js → index-5a93c9c3.js}

@@ -1,20 +1,20 @@
-import MultiWallet from './index-769b10c7.js';
-import './peernet-34ea081d.js';
-import './value-40634404.js';
+import { M as MultiWallet } from './peernet-1908438f.js';
+import './value-157ab062.js';
 
 /**
  * @params {String} network
  * @return {object} { identity, accounts, config }
  */
-var index = async (network) => {
+var index = async (password, network) => {
+    if (!password)
+        throw new Error('wallets need to be password protected.');
     let wallet = new MultiWallet(network);
     /**
      * @type {string}
      */
-    const mnemonic = await wallet.generate();
+    const mnemonic = await wallet.generate(password);
     wallet = new MultiWallet(network);
-    await wallet.recover(mnemonic, network);
-    console.log(await wallet.address);
+    await wallet.recover(mnemonic, password, network);
     /**
      * @type {object}
      */
@@ -28,8 +28,6 @@ var index = async (network) => {
             walletId: await external.id
         },
         accounts: [['main account', externalAddress, internalAddress]]
-        // config: {
-        //  }
     };
 };
 

package/exports/browser/{messages-1f20bad9.js → messages-c820f513.js}

@@ -1,5 +1,5 @@
-import { F as FormatInterface } from './peernet-34ea081d.js';
-import './value-40634404.js';
+import { F as FormatInterface } from './peernet-1908438f.js';
+import './value-157ab062.js';
 
 var proto$b = {
     data: new Uint8Array(),