working order ack

services/gunDB/contact-api/actions.js

@@ -923,7 +923,7 @@ const sendHRWithInitialMsg = async (
 /**
  * @typedef {object} SpontPaymentOptions
  * @prop {Common.Schema.OrderTargetType} type
- * @prop {string=} postID
+ * @prop {string=} ackInfo
  */
 /**
  * @typedef {object} OrderRes
@@ -968,11 +968,8 @@ const sendSpontaneousPayment = async (
       from: getUser()._.sea.pub,
       memo: memo || 'no memo',
       timestamp: Date.now(),
-      targetType: opts.type
+      targetType: opts.type,
-    }
+      ackInfo: opts.ackInfo
-
-    if (opts.type === 'tip') {
-      order.ackInfo = opts.postID
     }
 
     logger.info(JSON.stringify(order))
@@ -1009,7 +1006,7 @@ const sendSpontaneousPayment = async (
               )
             )
           } else {
-            res(ord._.get)
+            setTimeout(() => res(ord._.get), 0)
           }
         })
     })
@@ -1020,7 +1017,8 @@ const sendSpontaneousPayment = async (
       )}`
       throw new Error(msg)
     }
-
+    console.log('ORDER ID')
+    console.log(orderID)
     /** @type {import('shock-common').Schema.OrderResponse} */
     const encryptedOrderRes = await Utils.tryAndWait(
       gun =>
@@ -1030,12 +1028,13 @@ const sendSpontaneousPayment = async (
             .get(Key.ORDER_TO_RESPONSE)
             .get(orderID)
             .on(orderResponse => {
+              console.log(orderResponse)
               if (Schema.isOrderResponse(orderResponse)) {
                 res(orderResponse)
               }
             })
         }),
-      v => !Schema.isOrderResponse(v)
+      v => Schema.isOrderResponse(v)
     )
 
     if (!Schema.isOrderResponse(encryptedOrderRes)) {
@@ -1046,10 +1045,12 @@ const sendSpontaneousPayment = async (
       throw e
     }
 
-    /** @type {import('shock-common').Schema.OrderResponse} */
+    /** @type {import('shock-common').Schema.OrderResponse &{ackNode:string}} */
     const orderResponse = {
       response: await SEA.decrypt(encryptedOrderRes.response, ourSecret),
-      type: encryptedOrderRes.type
+      type: encryptedOrderRes.type,
+      //@ts-expect-error
+      ackNode: encryptedOrderRes.ackNode
     }
 
     logger.info('decoded orderResponse: ' + JSON.stringify(orderResponse))
@@ -1080,7 +1081,10 @@ const sendSpontaneousPayment = async (
       payment_request: orderResponse.response
     })
     const myLndPub = LNDHealthMananger.lndPub
-    if (opts.type !== 'contentReveal' && opts.type !== 'torrentSeed') {
+    if (
+      (opts.type !== 'contentReveal' && opts.type !== 'torrentSeed') ||
+      !orderResponse.ackNode
+    ) {
       SchemaManager.AddOrder({
         type: opts.type,
         amount: parseInt(payment.value_sat, 10),
@@ -1094,6 +1098,8 @@ const sendSpontaneousPayment = async (
       })
       return { payment }
     }
+    console.log('ACK NODE')
+    console.log(orderResponse.ackNode)
     /** @type {import('shock-common').Schema.OrderResponse} */
     const encryptedOrderAckRes = await Utils.tryAndWait(
       gun =>
@@ -1101,8 +1107,11 @@ const sendSpontaneousPayment = async (
           gun
             .user(to)
             .get(Key.ORDER_TO_RESPONSE)
-            .get(orderID)
+            .get(orderResponse.ackNode)
             .on(orderResponse => {
+              console.log(orderResponse)
+              console.log(Schema.isOrderResponse(orderResponse))
+
               if (Schema.isOrderResponse(orderResponse)) {
                 res(orderResponse)
               }
@@ -1113,7 +1122,7 @@ const sendSpontaneousPayment = async (
 
     if (!Schema.isOrderResponse(encryptedOrderAckRes)) {
       const e = TypeError(
-        `Expected OrderResponse got: ${typeof encryptedOrderAckRes}`
+        `Expected encryptedOrderAckRes got: ${typeof encryptedOrderAckRes}`
       )
       logger.error(e)
       throw e
@@ -1148,6 +1157,7 @@ const sendSpontaneousPayment = async (
     })
     return { payment, orderAck }
   } catch (e) {
+    console.log(e)
     logger.error('Error inside sendPayment()')
     logger.error(e)
     throw e

services/gunDB/contact-api/jobs/onOrders.js

@@ -2,6 +2,7 @@
  * @format
  */
 // @ts-check
+const Gun = require('gun')
 const { performance } = require('perf_hooks')
 const logger = require('winston')
 const isFinite = require('lodash/isFinite')
@@ -201,11 +202,15 @@ const listenerForAddr = (addr, SEA) => async (order, orderID) => {
     logger.info(
       `onOrders() -> Will now place the encrypted invoice in order to response usergraph: ${addr}`
     )
+    // @ts-expect-error
+    const ackNode = Gun.text.random()
 
     /** @type {import('shock-common').Schema.OrderResponse} */
     const orderResponse = {
       response: encInvoice,
-      type: 'invoice'
+      type: 'invoice',
+      //@ts-expect-error
+      ackNode
     }
 
     const invoicePutStartTime = performance.now()
@@ -231,14 +236,12 @@ const listenerForAddr = (addr, SEA) => async (order, orderID) => {
     const invoicePutEndTime = performance.now() - invoicePutStartTime
 
     logger.info(`[PERF] Added invoice to GunDB in ${invoicePutEndTime}ms`)
-
     /**
      *
-     * @type {Common.Schema.InvoiceWhenListed & {r_hash:Buffer,payment_addr:string}}
+     * @param {Common.Schema.InvoiceWhenListed & {r_hash:Buffer,payment_addr:string}} paidInvoice
      */
-    const paidInvoice = await new Promise(res => {
+    const invoicePaidCb = async paidInvoice => {
-      SchemaManager.addListenInvoice(invoice.r_hash, res)
+      console.log('INVOICE  PAID')
-    })
       const hashString = paidInvoice.r_hash.toString('hex')
       const {
         amt_paid_sat: amt,
@@ -264,25 +267,37 @@ const listenerForAddr = (addr, SEA) => async (order, orderID) => {
           break
         }
         case 'contentReveal': {
+          console.log('cONTENT REVEAL')
           //assuming digital product that only requires to be unlocked
           const postID = ackInfo
+          console.log('ACK INFO')
+          console.log(ackInfo)
           if (!Common.isPopulatedString(postID)) {
             break //create the coordinate, but stop because of the invalid id
           }
+          console.log('IS STRING')
           const selectedPost = await new Promise(res => {
             getUser()
               .get(Key.POSTS_NEW)
               .get(postID)
               .load(res)
           })
-        if (!Common.Schema.isPost(selectedPost)) {
+          console.log('LOAD ok')
+          console.log(selectedPost)
+          if (
+            !selectedPost ||
+            !selectedPost.status ||
+            selectedPost.status !== 'publish'
+          ) {
             break //create the coordinate, but stop because of the invalid post
           }
+          console.log('IS POST')
           /**
            * @type {Record<string,string>} <contentID,decryptedRef>
            */
           const contentsToSend = {}
           const mySecret = require('../../Mediator').getMySecret()
+          console.log('SECRET OK')
           await Common.Utils.asyncForEach(
             Object.entries(selectedPost.contentItems),
             async ([contentID, item]) => {
@@ -304,12 +319,14 @@ const listenerForAddr = (addr, SEA) => async (order, orderID) => {
           const encrypted = await SEA.encrypt(toSend, secret)
           const ordResponse = {
             type: 'orderAck',
-          content: encrypted
+            response: encrypted
           }
+          console.log('RES READY')
+
           await new Promise((res, rej) => {
             getUser()
               .get(Key.ORDER_TO_RESPONSE)
-            .get(orderID)
+              .get(ackNode)
               .put(ordResponse, ack => {
                 if (ack.err && typeof ack.err !== 'number') {
                   rej(
@@ -322,19 +339,24 @@ const listenerForAddr = (addr, SEA) => async (order, orderID) => {
                 }
               })
           })
+          console.log('RES SENT')
           break
         }
         case 'torrentSeed': {
+          console.log('TORRENT')
           const seedUrl = process.env.TORRENT_SEED_URL
           const seedToken = process.env.TORRENT_SEED_TOKEN
           if (!seedUrl || !seedToken) {
             break //service not available
           }
+          console.log('SEED URL OK')
           const token = crypto.randomBytes(32).toString('hex')
           const reqData = {
             seed_token: seedToken,
             wallet_token: token
           }
+          console.log(seedUrl)
+          console.log(seedToken)
           const res = await fetch(`${seedUrl}/api/enroll_token`, {
             method: 'POST',
             headers: {
@@ -342,21 +364,22 @@ const listenerForAddr = (addr, SEA) => async (order, orderID) => {
             },
             body: JSON.stringify(reqData)
           })
-        if (res.ok) {
+          if (res.status !== 200) {
             break //request didnt work, save coordinate anyway
           }
-
+          console.log('RES SEED OK')
           const ackData = { seedUrl, token }
           const toSend = JSON.stringify(ackData)
           const encrypted = await SEA.encrypt(toSend, secret)
           const serviceResponse = {
             type: 'orderAck',
-          content: encrypted
+            response: encrypted
           }
+          console.log('RES SEED SENT')
           await new Promise((res, rej) => {
             getUser()
               .get(Key.ORDER_TO_RESPONSE)
-            .get(orderID)
+              .get(ackNode)
               .put(serviceResponse, ack => {
                 if (ack.err && typeof ack.err !== 'number') {
                   rej(
@@ -389,6 +412,36 @@ const listenerForAddr = (addr, SEA) => async (order, orderID) => {
         toGunPub: myGunPub,
         invoiceMemo: memo
       })
+    }
+    console.log('WAITING INVOICE TO BE PAID')
+    new Promise(res => SchemaManager.addListenInvoice(invoice.r_hash, res))
+      .then(invoicePaidCb)
+      .catch(err => {
+        logger.error(
+          `error inside onOrders, orderAddr: ${addr}, orderID: ${orderID}, order: ${JSON.stringify(
+            order
+          )}`
+        )
+        logger.error(err)
+
+        /** @type {import('shock-common').Schema.OrderResponse} */
+        const orderResponse = {
+          response: err.message,
+          type: 'err'
+        }
+
+        getUser()
+          .get(Key.ORDER_TO_RESPONSE)
+          .get(orderID)
+          // @ts-expect-error
+          .put(orderResponse, ack => {
+            if (ack.err && typeof ack.err !== 'number') {
+              logger.error(
+                `Error saving encrypted invoice to order to response usergraph: ${ack}`
+              )
+            }
+          })
+      })
   } catch (err) {
     logger.error(
       `error inside onOrders, orderAddr: ${addr}, orderID: ${orderID}, order: ${JSON.stringify(

services/schema/index.js

@@ -387,6 +387,7 @@ class SchemaManager {
         .get(coordinateSHA256)
         .put(encryptedOrderString, ack => {
           if (ack.err && typeof ack.err !== 'number') {
+            console.log(ack)
             rej(
               new Error(
                 `Error saving coordinate order to user-graph: ${ack}`

src/routes.js

@@ -1192,12 +1192,17 @@ module.exports = async (
 
   app.post('/api/lnd/unifiedTrx', async (req, res) => {
     try {
-      const { type, amt, to, memo, feeLimit, postID } = req.body
+      const { type, amt, to, memo, feeLimit, ackInfo } = req.body
-
+      if (
-      if (type !== 'spont' && type !== 'post') {
+        type !== 'spontaneousPayment' &&
+        type !== 'tip' &&
+        type !== 'torrentSeed' &&
+        type !== 'contentReveal' &&
+        type !== 'other'
+      ) {
         return res.status(415).json({
           field: 'type',
-          errorMessage: `Only 'spont' and 'post' payments supported via this endpoint for now.`
+          errorMessage: `Only 'spontaneousPayment'| 'tip' | 'torrentSeed' | 'contentReveal' | 'other' payments supported via this endpoint for now.`
         })
       }
 
@@ -1231,17 +1236,17 @@ module.exports = async (
         })
       }
 
-      if (type === 'post' && typeof postID !== 'string') {
+      if (type === 'tip' && typeof ackInfo !== 'string') {
         return res.status(400).json({
-          field: 'postID',
+          field: 'ackInfo',
-          errorMessage: `Send postID`
+          errorMessage: `Send ackInfo`
         })
       }
 
       return res.status(200).json(
         await GunActions.sendSpontaneousPayment(to, amt, memo, feeLimit, {
           type,
-          postID
+          ackInfo
         })
       )
     } catch (e) {
@@ -2164,10 +2169,12 @@ module.exports = async (
   app.post(`/api/gun/wall/`, async (req, res) => {
     try {
       const { tags, title, contentItems } = req.body
+      const SEA = require('../services/gunDB/Mediator').mySEA
       return res
         .status(200)
-        .json(await GunActions.createPostNew(tags, title, contentItems))
+        .json(await GunActions.createPostNew(tags, title, contentItems, SEA))
     } catch (e) {
+      console.log(e)
       return res.status(500).json({
         errorMessage:
           (typeof e === 'string' ? e : e.message) || 'Unknown error.'