Support multi-contributor bounty payouts

app/b/[owner]/[repo]/issues/[issueNumber]/approve-button.tsx

@@ -17,27 +17,29 @@ export function ApproveButton({ owner, repo, issueNumber }: Props) {
   const router = useRouter();
   const [isPending, startTransition] = useTransition();
   const [error, setError] = useState<string | null>(null);
-  const [successTxHash, setSuccessTxHash] = useState<string | null>(null);
+  const [successMessage, setSuccessMessage] = useState<string | null>(null);
 
   const onApprove = () => {
     setError(null);
-    setSuccessTxHash(null);
+    setSuccessMessage(null);
 
     startTransition(async () => {
       try {
         const response = await approveBounty({ owner, repo, issueNumber });
-        const { payoutType, recipientEmail, recipientWallet } = response.payout;
-        
+        const { payoutType, recipientEmail, recipientWallet, recipients } = response.payout;
+
         let message = "";
-        if (payoutType === "wallet" && recipientWallet) {
+        if (recipients.length > 1) {
+          message = `Payout split across ${recipients.length} recipients.`;
+        } else if (payoutType === "wallet" && recipientWallet) {
           message = `Payout sent to wallet ${recipientWallet.slice(0, 6)}...${recipientWallet.slice(-4)}`;
         } else if (payoutType === "email" && recipientEmail) {
           message = `Payout sent to ${recipientEmail}`;
         } else if (payoutType === "unclaimed") {
           message = "Winner not connected. Notified via issue comment to claim.";
         }
 
-        setSuccessTxHash(message);
+        setSuccessMessage(message);
         router.refresh();
       } catch (e) {
         setError(e instanceof Error ? e.message : "Failed to approve payout");
@@ -64,8 +66,8 @@ export function ApproveButton({ owner, repo, issueNumber }: Props) {
         )}
       </Button>
       {error ? <p className="mt-3 text-sm text-red-300">{error}</p> : null}
-      {successTxHash ? (
-        <p className="mt-3 text-sm text-emerald-300">{successTxHash}</p>
+      {successMessage ? (
+        <p className="mt-3 text-sm text-emerald-300">{successMessage}</p>
       ) : null}
     </div>
   );

lib/api/client.ts

@@ -166,6 +166,15 @@ export async function approveBounty(params: {
     txHash: string | null;
     transactionId: string;
     approvedBy: string;
+    recipients: Array<{
+      username: string;
+      amount: number;
+      payoutType: "wallet" | "email" | "unclaimed";
+      recipientEmail?: string | null;
+      recipientWallet?: string | null;
+      txHash: string | null;
+      transactionId: string;
+    }>;
   };
 }> {
   const res = await fetch(

lib/bounty/services/approve-payout.ts

@@ -57,8 +57,7 @@ export async function approveBountyPayout(params: {
     }
   }
 
-  // only single payout for now, later multiple payouts
-  const payoutResult = await resolveAndPayout({
+  const payout = await resolveAndPayout({
     owner: params.owner,
     repo: params.repo,
     issueNumber: params.issueNumber,
@@ -67,14 +66,15 @@ export async function approveBountyPayout(params: {
     amount: bounty.total_amount,
     issueId,
   });
+  const primaryPayoutResult = payout.results[0];
 
   const now = new Date().toISOString();
 
   const { error: updateError } = await supabase
     .from("bounties")
     .update({
       status: "PAID",
-      payout_tx_hash: payoutResult.txHash,
+      payout_tx_hash: primaryPayoutResult.txHash,
       paid_at: now,
       approved_by: params.approvedBy,
     })
@@ -84,38 +84,44 @@ export async function approveBountyPayout(params: {
     throw new Error(`Failed to update bounty status to PAID: ${updateError.message}`);
   }
 
-  const { error: payoutEventError } = await supabase.from("payout_events").insert({
+  const payoutEvents = payout.results.map((result) => ({
     issue_id: issueId,
-    recipient_username: bounty.winning_pr_author,
-    amount: bounty.total_amount,
-    locus_transaction_id: payoutResult.transactionId,
-    transaction_hash: payoutResult.txHash,
-    status: "SUCCESS",
+    recipient_username: result.recipientUsername,
+    amount: result.amount,
+    locus_transaction_id: result.transactionId,
+    transaction_hash: result.txHash,
+    status: "SUCCESS" as const,
     metadata: {
       approved_by: params.approvedBy,
       payout_source: "web",
-      payout_type: payoutResult.payoutType,
-      recipient_email: payoutResult.recipientEmail,
-      recipient_wallet: payoutResult.recipientWallet,
+      payout_type: result.payoutType,
+      recipient_email: result.recipientEmail,
+      recipient_wallet: result.recipientWallet,
+      split_payout: payout.isSplit,
     },
-  });
+  }));
+
+  const { error: payoutEventError } = await supabase.from("payout_events").insert(payoutEvents);
 
   if (payoutEventError) {
     throw new Error(`Failed to persist payout event: ${payoutEventError.message}`);
   }
 
-  const { error: activityError } = await supabase.from("activity_events").insert({
+  const activityEvents = payout.results.map((result) => ({
     issue_id: issueId,
-    event_type: "PAYOUT_SENT",
-    actor_username: bounty.winning_pr_author,
-    amount: bounty.total_amount,
-    tx_hash: payoutResult.txHash,
+    event_type: "PAYOUT_SENT" as const,
+    actor_username: result.recipientUsername,
+    amount: result.amount,
+    tx_hash: result.txHash,
     metadata: {
       approved_by: params.approvedBy,
       payout_source: "web",
-      payout_type: payoutResult.payoutType,
+      payout_type: result.payoutType,
+      split_payout: payout.isSplit,
     },
-  });
+  }));
+
+  const { error: activityError } = await supabase.from("activity_events").insert(activityEvents);
 
   if (activityError) {
     throw new Error(`Failed to persist payout activity: ${activityError.message}`);
@@ -126,12 +132,21 @@ export async function approveBountyPayout(params: {
   return {
     issueId,
     amount: bounty.total_amount,
-    recipient: bounty.winning_pr_author,
-    payoutType: payoutResult.payoutType,
-    recipientEmail: payoutResult.recipientEmail,
-    recipientWallet: payoutResult.recipientWallet,
-    txHash: payoutResult.txHash,
-    transactionId: payoutResult.transactionId,
+    recipient: primaryPayoutResult.recipientUsername,
+    payoutType: primaryPayoutResult.payoutType,
+    recipientEmail: primaryPayoutResult.recipientEmail,
+    recipientWallet: primaryPayoutResult.recipientWallet,
+    txHash: primaryPayoutResult.txHash,
+    transactionId: primaryPayoutResult.transactionId,
     approvedBy: params.approvedBy,
+    recipients: payout.results.map((result) => ({
+      username: result.recipientUsername,
+      amount: result.amount,
+      payoutType: result.payoutType,
+      recipientEmail: result.recipientEmail,
+      recipientWallet: result.recipientWallet,
+      txHash: result.txHash,
+      transactionId: result.transactionId,
+    })),
   };
-}
+}