rethinking boost

api/paidAction/boost.js

@@ -0,0 +1,77 @@
+import { msatsToSats, satsToMsats } from '@/lib/format'
+
+export const anonable = false
+export const supportsPessimism = false
+export const supportsOptimism = true
+
+export async function getCost ({ sats }) {
+  return satsToMsats(sats)
+}
+
+export async function perform ({ invoiceId, sats, id: itemId, ...args }, { me, cost, tx }) {
+  itemId = parseInt(itemId)
+
+  let invoiceData = {}
+  if (invoiceId) {
+    invoiceData = { invoiceId, invoiceActionState: 'PENDING' }
+    // store a reference to the item in the invoice
+    await tx.invoice.update({
+      where: { id: invoiceId },
+      data: { actionId: itemId }
+    })
+  }
+
+  const act = await tx.itemAct.create({ data: { msats: cost, itemId, userId: me.id, act: 'BOOST', ...invoiceData } })
+
+  const [{ path }] = await tx.$queryRaw`
+    SELECT ltree2text(path) as path FROM "Item" WHERE id = ${itemId}::INTEGER`
+  return { id: itemId, sats, act: 'BOOST', path, actId: act.id }
+}
+
+export async function retry ({ invoiceId, newInvoiceId }, { tx, cost }) {
+  await tx.itemAct.updateMany({ where: { invoiceId }, data: { invoiceId: newInvoiceId, invoiceActionState: 'PENDING' } })
+  const [{ id, path }] = await tx.$queryRaw`
+    SELECT "Item".id, ltree2text(path) as path
+    FROM "Item"
+    JOIN "ItemAct" ON "Item".id = "ItemAct"."itemId"
+    WHERE "ItemAct"."invoiceId" = ${newInvoiceId}::INTEGER`
+  return { id, sats: msatsToSats(cost), act: 'BOOST', path }
+}
+
+export async function onPaid ({ invoice, actId }, { models, tx }) {
+  let itemAct
+  if (invoice) {
+    await tx.itemAct.updateMany({
+      where: { invoiceId: invoice.id },
+      data: {
+        invoiceActionState: 'PAID'
+      }
+    })
+    itemAct = await tx.itemAct.findFirst({ where: { invoiceId: invoice.id } })
+  } else if (actId) {
+    itemAct = await tx.itemAct.findFirst({ where: { id: { in: actId } } })
+  } else {
+    throw new Error('No invoice or actId')
+  }
+
+  // increment boost on item
+  await tx.item.update({
+    where: { id: itemAct.itemId },
+    data: {
+      boost: { increment: msatsToSats(itemAct.msats) }
+    }
+  })
+
+  await tx.$executeRaw`
+    INSERT INTO pgboss.job (name, data, retrylimit, retrybackoff, startafter, expirein)
+    VALUES ('expireBoost', jsonb_build_object('id', ${itemAct.itemId}::INTEGER), 21, true,
+              now() + interval '30 days', interval '40 days')`
+}
+
+export async function onFail ({ invoice }, { tx }) {
+  await tx.itemAct.updateMany({ where: { invoiceId: invoice.id }, data: { invoiceActionState: 'FAILED' } })
+}
+
+export async function describe ({ id: itemId, sats }, { actionId, cost }) {
+  return `SN: boost ${sats ?? msatsToSats(cost)} sats to #${itemId ?? actionId}`
+}

api/paidAction/index.js

@@ -13,6 +13,7 @@ import * as TERRITORY_UPDATE from './territoryUpdate'
 import * as TERRITORY_BILLING from './territoryBilling'
 import * as TERRITORY_UNARCHIVE from './territoryUnarchive'
 import * as DONATE from './donate'
+import * as BOOST from './boost'
 import wrapInvoice from 'wallets/wrap'
 import { createInvoice as createUserInvoice } from 'wallets/server'
 
@@ -21,6 +22,7 @@ export const paidActions = {
   ITEM_UPDATE,
   ZAP,
   DOWN_ZAP,
+  BOOST,
   POLL_VOTE,
   TERRITORY_CREATE,
   TERRITORY_UPDATE,
@@ -186,7 +188,12 @@ export async function retryPaidAction (actionType, args, context) {
   context.optimistic = true
   context.me = await models.user.findUnique({ where: { id: me.id } })
 
-  const { msatsRequested, actionId } = await models.invoice.findUnique({ where: { id: invoiceId, actionState: 'FAILED' } })
+  const failedInvoice = await models.invoice.findUnique({ where: { id: invoiceId, actionState: 'FAILED' } })
+  if (!failedInvoice) {
+    throw new Error(`retryPaidAction - invoice not found or not in failed state ${actionType}`)
+  }
+
+  const { msatsRequested, actionId } = failedInvoice
   context.cost = BigInt(msatsRequested)
   context.actionId = actionId
   const invoiceArgs = await createSNInvoice(actionType, args, context)

api/paidAction/itemCreate.js

@@ -195,6 +195,13 @@ export async function onPaid ({ invoice, id }, context) {
     INSERT INTO pgboss.job (name, data, retrylimit, retrybackoff, startafter)
     VALUES ('imgproxy', jsonb_build_object('id', ${item.id}::INTEGER), 21, true, now() + interval '5 seconds')`
 
+  if (item.boost > 0) {
+    await tx.$executeRaw`
+    INSERT INTO pgboss.job (name, data, retrylimit, retrybackoff, startafter, expirein)
+    VALUES ('expireBoost', jsonb_build_object('id', ${item.id}::INTEGER), 21, true,
+              now() + interval '30 days', interval '40 days')`
+  }
+
   if (item.parentId) {
     // denormalize ncomments, lastCommentAt, and "weightedComments" for ancestors, and insert into reply table
     await tx.$executeRaw`

api/paidAction/itemUpdate.js

@@ -13,7 +13,7 @@ export async function getCost ({ id, boost = 0, uploadIds }, { me, models }) {
   // or more boost
   const old = await models.item.findUnique({ where: { id: parseInt(id) } })
   const { totalFeesMsats } = await uploadFees(uploadIds, { models, me })
-  return BigInt(totalFeesMsats) + satsToMsats(boost - (old.boost || 0))
+  return BigInt(totalFeesMsats) + satsToMsats(boost - old.boost)
 }
 
 export async function perform (args, context) {
@@ -30,9 +30,10 @@ export async function perform (args, context) {
     }
   })
 
-  const boostMsats = satsToMsats(boost - (old.boost || 0))
+  const newBoost = boost - old.boost
   const itemActs = []
-  if (boostMsats > 0) {
+  if (newBoost > 0) {
+    const boostMsats = satsToMsats(newBoost)
     itemActs.push({
       msats: boostMsats, act: 'BOOST', userId: me?.id || USER_ID.anon
     })
@@ -54,15 +55,19 @@ export async function perform (args, context) {
     data: { paid: true }
   })
 
+  // we put boost in the where clause because we don't want to update the boost
+  // if it has changed concurrently
   const item = await tx.item.update({
-    where: { id: parseInt(id) },
+    where: { id: parseInt(id), boost: old.boost },
     include: {
       mentions: true,
       itemReferrers: { include: { refereeItem: true } }
     },
     data: {
       ...data,
-      boost,
+      boost: {
+        increment: newBoost
+      },
       pollOptions: {
         createMany: {
           data: pollOptions?.map(option => ({ option }))
@@ -126,8 +131,17 @@ export async function perform (args, context) {
     }
   })
 
-  await tx.$executeRaw`INSERT INTO pgboss.job (name, data, retrylimit, retrybackoff, startafter)
-    VALUES ('imgproxy', jsonb_build_object('id', ${id}::INTEGER), 21, true, now() + interval '5 seconds')`
+  await tx.$executeRaw`
+    INSERT INTO pgboss.job (name, data, retrylimit, retrybackoff, startafter, expirein)
+    VALUES ('imgproxy', jsonb_build_object('id', ${id}::INTEGER), 21, true,
+              now() + interval '5 seconds', interval '1 day')`
+
+  if (newBoost > 0) {
+    await tx.$executeRaw`
+      INSERT INTO pgboss.job (name, data, retrylimit, retrybackoff, startafter, expirein)
+      VALUES ('expireBoost', jsonb_build_object('id', ${id}::INTEGER), 21, true,
+                now() + interval '30 days', interval '40 days')`
+  }
 
   await performBotBehavior(args, context)