allow signing events with a custom signing function on pool.publish()

filter.js

@@ -1,6 +1,6 @@
 export function matchFilter(filter, event) {
-  if (filter.ids && filter.ids.indexOf(event.id) !== -1) return false
-  if (filter.kinds && filter.kinds.indexOf(event.kind) !== -1) return false
+  if (filter.ids && filter.ids.indexOf(event.id) === -1) return false
+  if (filter.kinds && filter.kinds.indexOf(event.kind) === -1) return false
   if (filter.authors && filter.authors.indexOf(event.pubkey) === -1)
     return false
 
@@ -8,7 +8,9 @@ export function matchFilter(filter, event) {
     if (f[0] === '#') {
       if (
         filter[f] &&
-        !event.tags.find(([t, v]) => t === f.slice(1) && v === filter[f])
+        !event.tags.find(
+          ([t, v]) => t === f.slice(1) && filter[f].indexOf(v) !== -1
+        )
       )
         return false
     }

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.0",
+  "version": "0.19.0",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",

pool.js

@@ -1,12 +1,18 @@
-import {getEventHash, signEvent} from './event'
+import {getEventHash, verifySignature, signEvent} from './event'
 import {relayConnect, normalizeRelayURL} from './relay'
 
 export function relayPool() {
   var globalPrivateKey
+  var globalSigningFunction
+
   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 = []
@@ -72,6 +78,9 @@ export function relayPool() {
     setPrivateKey(privateKey) {
       globalPrivateKey = privateKey
     },
+    registerSigningFunction(fn) {
+      globalSigningFunction = fn
+    },
     setPolicy(key, value) {
       poolPolicy[key] = value
     },
@@ -111,7 +120,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) {
@@ -119,9 +128,21 @@ export function relayPool() {
 
         if (globalPrivateKey) {
           event.sig = await signEvent(event, globalPrivateKey)
+        } else if (globalSigningFunction) {
+          event.sig = await globalSigningFunction(event)
+          if (!event.sig) {
+            // abort here
+            return
+          } else {
+            // check
+            if (!(await verifySignature(event)))
+              throw new Error(
+                'signature provided by custom signing function is invalid.'
+              )
+          }
         } else {
           throw new Error(
-            "can't publish unsigned event. either sign this event beforehand or pass a private key while initializing this relay pool so it can be signed automatically."
+            "can't publish unsigned event. either sign this event beforehand, provide a signing function or pass a private key while initializing this relay pool so it can be signed automatically."
           )
         }
       }
@@ -136,28 +157,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