prevent blocking waiting times on publish (unless "wait" is set in the pool policy).

nip06.js

@@ -8,13 +8,13 @@ import {HDKey} from 'micro-bip32'
 
 export function privateKeyFromSeed(seed) {
   let root = HDKey.fromMasterSeed(Buffer.from(seed, 'hex'))
-  return Buffer.from(root.derive(`m/44'/1237'/0'/0'`).privateKey).toString(
+  return Buffer.from(root.derive(`m/44'/1237'/0'/0/0`).privateKey).toString(
     'hex'
   )
 }
 
 export function seedFromWords(mnemonic) {
-  return Buffer.from(mnemonicToSeedSync(mnemonic, wordlist)).toString('hex')
+  return Buffer.from(mnemonicToSeedSync(mnemonic)).toString('hex')
 }
 
 export function generateSeedWords() {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-tools",
-  "version": "0.16.2",
+  "version": "0.18.0",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",

pool.js

@@ -6,7 +6,11 @@ export function relayPool() {
   const poolPolicy = {
     // setting this to a number will cause events to be published to a random
     // set of relays only, instead of publishing to all relays all the time
-    randomChoice: null
+    randomChoice: null,
+
+    // setting this to true will cause .publish() calls to wait until the event has
+    // been published -- or at least attempted to be published -- to all relays
+    wait: false
   }
   const relays = {}
   const noticeCallbacks = []
@@ -111,7 +115,7 @@ export function relayPool() {
       let index = noticeCallbacks.indexOf(cb)
       if (index !== -1) noticeCallbacks.splice(index, 1)
     },
-    async publish(event, statusCallback = (status, relayURL) => {}) {
+    async publish(event, statusCallback) {
       event.id = getEventHash(event)
 
       if (!event.sig) {
@@ -136,28 +140,37 @@ export function relayPool() {
 
       let successes = 0
 
-      for (let i = 0; i < writeable.length; i++) {
-        let {relay} = writeable[i]
+      if (poolPolicy.wait) {
+        for (let i = 0; i < writeable.length; i++) {
+          let {relay} = writeable[i]
 
-        try {
-          await new Promise(async (resolve, reject) => {
-            try {
-              await relay.publish(event, status => {
-                statusCallback(status, relay.url)
-                resolve()
-              })
-            } catch (err) {
-              statusCallback(-1, relay.url)
+          try {
+            await new Promise(async (resolve, reject) => {
+              try {
+                await relay.publish(event, status => {
+                  if (statusCallback) statusCallback(status, relay.url)
+                  resolve()
+                })
+              } catch (err) {
+                if (statusCallback) statusCallback(-1, relay.url)
+              }
+            })
+
+            successes++
+            if (successes >= maxTargets) {
+              break
             }
-          })
-
-          successes++
-          if (successes >= maxTargets) {
-            break
+          } catch (err) {
+            /***/
           }
-        } catch (err) {
-          /***/
         }
+      } else {
+        writeable.forEach(async ({relay}) => {
+          let callback = statusCallback
+            ? status => statusCallback(status, relay.url)
+            : null
+          relay.publish(event, callback)
+        })
       }
 
       return event