Merge branch 'main' into austin/dc-hackathon

common/group.ts

@@ -39,3 +39,4 @@ export type GroupLink = {
   createdTime: number
   userId?: string
 }
+export type GroupContractDoc = { contractId: string; createdTime: number }

functions/src/create-market.ts

@@ -15,7 +15,7 @@ import {
 import { slugify } from '../../common/util/slugify'
 import { randomString } from '../../common/util/random'
 
-import { chargeUser, getContract, isProd } from './utils'
+import { isProd } from './utils'
 import { APIError, AuthedUser, newEndpoint, validate, zTimestamp } from './api'
 
 import { FIXED_ANTE, FREE_MARKETS_PER_USER_MAX } from '../../common/economy'
@@ -36,7 +36,7 @@ import { getPseudoProbability } from '../../common/pseudo-numeric'
 import { JSONContent } from '@tiptap/core'
 import { uniq, zip } from 'lodash'
 import { Bet } from '../../common/bet'
-import { FieldValue } from 'firebase-admin/firestore'
+import { FieldValue, Transaction } from 'firebase-admin/firestore'
 
 const descScehma: z.ZodType<JSONContent> = z.lazy(() =>
   z.intersection(
@@ -107,6 +107,7 @@ export async function createMarketHelper(body: any, auth: AuthedUser) {
     visibility = 'public',
   } = validate(bodySchema, body)
 
+  return await firestore.runTransaction(async (trans) => {
     let min, max, initialProb, isLogScale, answers
 
     if (outcomeType === 'PSEUDO_NUMERIC' || outcomeType === 'NUMERIC') {
@@ -115,7 +116,8 @@ export async function createMarketHelper(body: any, auth: AuthedUser) {
       if (max - min <= 0.01 || initialValue <= min || initialValue >= max)
         throw new APIError(400, 'Invalid range.')
 
-    initialProb = getPseudoProbability(initialValue, min, max, isLogScale) * 100
+      initialProb =
+        getPseudoProbability(initialValue, min, max, isLogScale) * 100
 
       if (initialProb < 1 || initialProb > 99)
         if (outcomeType === 'PSEUDO_NUMERIC')
@@ -134,7 +136,7 @@ export async function createMarketHelper(body: any, auth: AuthedUser) {
       ;({ answers } = validate(multipleChoiceSchema, body))
     }
 
-  const userDoc = await firestore.collection('users').doc(auth.uid).get()
+    const userDoc = await trans.get(firestore.collection('users').doc(auth.uid))
     if (!userDoc.exists) {
       throw new APIError(400, 'No user exists with the authenticated user ID.')
     }
@@ -150,15 +152,15 @@ export async function createMarketHelper(body: any, auth: AuthedUser) {
     let group: Group | null = null
     if (groupId) {
       const groupDocRef = firestore.collection('groups').doc(groupId)
-    const groupDoc = await groupDocRef.get()
+      const groupDoc = await trans.get(groupDocRef)
       if (!groupDoc.exists) {
         throw new APIError(400, 'No group exists with the given group ID.')
       }
 
       group = groupDoc.data() as Group
-    const groupMembersSnap = await firestore
+      const groupMembersSnap = await trans.get(
-      .collection(`groups/${groupId}/groupMembers`)
+        firestore.collection(`groups/${groupId}/groupMembers`)
-      .get()
+      )
       const groupMemberDocs = groupMembersSnap.docs.map(
         (doc) => doc.data() as { userId: string; createdTime: number }
       )
@@ -173,7 +175,7 @@ export async function createMarketHelper(body: any, auth: AuthedUser) {
         )
       }
     }
-  const slug = await getSlug(question)
+    const slug = await getSlug(trans, question)
     const contractRef = firestore.collection('contracts').doc()
 
     console.log(
@@ -224,28 +226,36 @@ export async function createMarketHelper(body: any, auth: AuthedUser) {
         : DEV_HOUSE_LIQUIDITY_PROVIDER_ID
       : user.id
 
-  if (ante) await chargeUser(providerId, ante, true)
+    if (ante) {
-  if (deservesFreeMarket)
+      const delta = FieldValue.increment(-ante)
-    await firestore
+      const providerDoc = firestore.collection('users').doc(providerId)
-      .collection('users')
+      await trans.update(providerDoc, { balance: delta, totalDeposits: delta })
-      .doc(user.id)
+    }
-      .update({ freeMarketsCreated: FieldValue.increment(1) })
+
+    if (deservesFreeMarket) {
+      await trans.update(firestore.collection('users').doc(user.id), {
+        freeMarketsCreated: FieldValue.increment(1),
+      })
+    }
 
     await contractRef.create(contract)
 
     if (group != null) {
-    const groupContractsSnap = await firestore
+      const groupContractsSnap = await trans.get(
-      .collection(`groups/${groupId}/groupContracts`)
+        firestore.collection(`groups/${groupId}/groupContracts`)
-      .get()
+      )
       const groupContracts = groupContractsSnap.docs.map(
         (doc) => doc.data() as { contractId: string; createdTime: number }
       )
+
       if (!groupContracts.map((c) => c.contractId).includes(contractRef.id)) {
-      await createGroupLinks(group, [contractRef.id], auth.uid)
+        await createGroupLinks(trans, group, [contractRef.id], auth.uid)
+
         const groupContractRef = firestore
           .collection(`groups/${groupId}/groupContracts`)
           .doc(contract.id)
-      await groupContractRef.set({
+
+        await trans.set(groupContractRef, {
           contractId: contract.id,
           createdTime: Date.now(),
         })
@@ -264,7 +274,7 @@ export async function createMarketHelper(body: any, auth: AuthedUser) {
         ante
       )
 
-    await liquidityDoc.set(lp)
+      await trans.set(liquidityDoc, lp)
     } else if (outcomeType === 'MULTIPLE_CHOICE') {
       const betCol = firestore.collection(`contracts/${contract.id}/bets`)
       const betDocs = (answers ?? []).map(() => betCol.doc())
@@ -282,21 +292,23 @@ export async function createMarketHelper(body: any, auth: AuthedUser) {
       )
 
       await Promise.all(
-      zip(bets, betDocs).map(([bet, doc]) => doc?.create(bet as Bet))
+        zip(bets, betDocs).map(([bet, doc]) =>
+          doc ? trans.create(doc, bet as Bet) : undefined
+        )
       )
       await Promise.all(
         zip(answerObjects, answerDocs).map(([answer, doc]) =>
-        doc?.create(answer as Answer)
+          doc ? trans.create(doc, answer as Answer) : undefined
         )
       )
-    await contractRef.update({ answers: answerObjects })
+      await trans.update(contractRef, { answers: answerObjects })
     } else if (outcomeType === 'FREE_RESPONSE') {
       const noneAnswerDoc = firestore
         .collection(`contracts/${contract.id}/answers`)
         .doc('0')
 
       const noneAnswer = getNoneAnswer(contract.id, user)
-    await noneAnswerDoc.set(noneAnswer)
+      await trans.set(noneAnswerDoc, noneAnswer)
 
       const anteBetDoc = firestore
         .collection(`contracts/${contract.id}/bets`)
@@ -307,7 +319,7 @@ export async function createMarketHelper(body: any, auth: AuthedUser) {
         contract as FreeResponseContract,
         anteBetDoc.id
       )
-    await anteBetDoc.set(anteBet)
+      await trans.set(anteBetDoc, anteBet)
     } else if (outcomeType === 'NUMERIC') {
       const anteBetDoc = firestore
         .collection(`contracts/${contract.id}/bets`)
@@ -320,16 +332,17 @@ export async function createMarketHelper(body: any, auth: AuthedUser) {
         anteBetDoc.id
       )
 
-    await anteBetDoc.set(anteBet)
+      await trans.set(anteBetDoc, anteBet)
     }
 
     return contract
+  })
 }
 
-const getSlug = async (question: string) => {
+const getSlug = async (trans: Transaction, question: string) => {
   const proposedSlug = slugify(question)
 
-  const preexistingContract = await getContractFromSlug(proposedSlug)
+  const preexistingContract = await getContractFromSlug(trans, proposedSlug)
 
   return preexistingContract
     ? proposedSlug + '-' + randomString()
@@ -338,35 +351,31 @@ const getSlug = async (question: string) => {
 
 const firestore = admin.firestore()
 
-export async function getContractFromSlug(slug: string) {
+async function getContractFromSlug(trans: Transaction, slug: string) {
-  const snap = await firestore
+  const snap = await trans.get(
-    .collection('contracts')
+    firestore.collection('contracts').where('slug', '==', slug)
-    .where('slug', '==', slug)
+  )
-    .get()
 
   return snap.empty ? undefined : (snap.docs[0].data() as Contract)
 }
 
 async function createGroupLinks(
+  trans: Transaction,
   group: Group,
   contractIds: string[],
   userId: string
 ) {
   for (const contractId of contractIds) {
-    const contract = await getContract(contractId)
+    const contractRef = firestore.collection('contracts').doc(contractId)
+    const contract = (await trans.get(contractRef)).data() as Contract
+
     if (!contract?.groupSlugs?.includes(group.slug)) {
-      await firestore
+      await trans.update(contractRef, {
-        .collection('contracts')
-        .doc(contractId)
-        .update({
         groupSlugs: uniq([group.slug, ...(contract?.groupSlugs ?? [])]),
       })
     }
     if (!contract?.groupLinks?.map((gl) => gl.groupId).includes(group.id)) {
-      await firestore
+      await trans.update(contractRef, {
-        .collection('contracts')
-        .doc(contractId)
-        .update({
         groupLinks: [
           {
             groupId: group.id,

functions/src/on-update-contract.ts

@@ -2,6 +2,8 @@ import * as functions from 'firebase-functions'
 import { getUser } from './utils'
 import { createCommentOrAnswerOrUpdatedContractNotification } from './create-notification'
 import { Contract } from '../../common/contract'
+import { GroupContractDoc } from '../../common/group'
+import * as admin from 'firebase-admin'
 
 export const onUpdateContract = functions.firestore
   .document('contracts/{contractId}')
@@ -9,17 +11,14 @@ export const onUpdateContract = functions.firestore
     const contract = change.after.data() as Contract
     const previousContract = change.before.data() as Contract
     const { eventId } = context
-    const { openCommentBounties, closeTime, question } = contract
+    const { closeTime, question } = contract
 
-    if (
+    if (!previousContract.isResolved && contract.isResolved) {
-      !previousContract.isResolved &&
-      contract.isResolved &&
-      (openCommentBounties ?? 0) > 0
-    ) {
       // No need to notify users of resolution, that's handled in resolve-market
       return
-    }
+    } else if (previousContract.groupSlugs !== contract.groupSlugs) {
-    if (
+      await handleContractGroupUpdated(previousContract, contract)
+    } else if (
       previousContract.closeTime !== closeTime ||
       previousContract.question !== question
     ) {
@@ -51,3 +50,43 @@ async function handleUpdatedCloseTime(
     contract
   )
 }
+
+async function handleContractGroupUpdated(
+  previousContract: Contract,
+  contract: Contract
+) {
+  const prevLength = previousContract.groupSlugs?.length ?? 0
+  const newLength = contract.groupSlugs?.length ?? 0
+  if (prevLength < newLength) {
+    // Contract was added to a new group
+    const groupId = contract.groupLinks?.find(
+      (link) =>
+        !previousContract.groupLinks
+          ?.map((l) => l.groupId)
+          .includes(link.groupId)
+    )?.groupId
+    if (!groupId) throw new Error('Could not find new group id')
+
+    await firestore
+      .collection(`groups/${groupId}/groupContracts`)
+      .doc(contract.id)
+      .set({
+        contractId: contract.id,
+        createdTime: Date.now(),
+      } as GroupContractDoc)
+  }
+  if (prevLength > newLength) {
+    // Contract was removed from a group
+    const groupId = previousContract.groupLinks?.find(
+      (link) =>
+        !contract.groupLinks?.map((l) => l.groupId).includes(link.groupId)
+    )?.groupId
+    if (!groupId) throw new Error('Could not find old group id')
+
+    await firestore
+      .collection(`groups/${groupId}/groupContracts`)
+      .doc(contract.id)
+      .delete()
+  }
+}
+const firestore = admin.firestore()

functions/src/scripts/update-groups.ts

@@ -89,17 +89,20 @@ const getGroups = async () => {
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 async function updateTotalContractsAndMembers() {
   const groups = await getGroups()
-  for (const group of groups) {
+  await Promise.all(
+    groups.map(async (group) => {
       log('updating group total contracts and members', group.slug)
       const groupRef = admin.firestore().collection('groups').doc(group.id)
-    const totalMembers = (await groupRef.collection('groupMembers').get()).size
+      const totalMembers = (await groupRef.collection('groupMembers').get())
+        .size
       const totalContracts = (await groupRef.collection('groupContracts').get())
         .size
       await groupRef.update({
         totalMembers,
         totalContracts,
       })
-  }
+    })
+  )
 }
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 async function removeUnusedMemberAndContractFields() {
@@ -117,6 +120,6 @@ async function removeUnusedMemberAndContractFields() {
 if (require.main === module) {
   initAdmin()
   // convertGroupFieldsToGroupDocuments()
-  // updateTotalContractsAndMembers()
+  updateTotalContractsAndMembers()
-  removeUnusedMemberAndContractFields()
+  // removeUnusedMemberAndContractFields()
 }

web/components/card.tsx

@@ -5,7 +5,7 @@ export function Card(props: JSX.IntrinsicElements['div']) {
   return (
     <div
       className={clsx(
-        'cursor-pointer rounded-lg border-2 bg-white transition-shadow hover:shadow-md focus:shadow-md',
+        'cursor-pointer rounded-lg border bg-white transition-shadow hover:shadow-md focus:shadow-md',
         className
       )}
       {...rest}

web/components/contract/contract-tabs.tsx

@@ -80,8 +80,8 @@ const CommentsTabContent = memo(function CommentsTabContent(props: {
   const { contract } = props
   const tips = useTipTxns({ contractId: contract.id })
   const comments = useComments(contract.id) ?? props.comments
-  const [sort, setSort] = usePersistentState<'Newest' | 'Best'>('Newest', {
+  const [sort, setSort] = usePersistentState<'Newest' | 'Best'>('Best', {
-    key: `contract-${contract.id}-comments-sort`,
+    key: `contract-comments-sort`,
     store: storageStore(safeLocalStorage()),
   })
   const me = useUser()

web/components/onboarding/group-selector-dialog.tsx

@@ -72,6 +72,7 @@ export default function GroupSelectorDialog(props: {
           ) : (
             displayedGroups.map((group) => (
               <PillButton
+                key={group.id}
                 selected={memberGroupIds.includes(group.id)}
                 onSelect={withTracking(
                   () =>

web/lib/firebase/groups.ts

@@ -191,6 +191,7 @@ export async function leaveGroup(group: Group, userId: string): Promise<void> {
   return await deleteDoc(memberDoc)
 }
 
+// TODO: This doesn't check if the user has permission to do this
 export async function addContractToGroup(
   group: Group,
   contract: Contract,
@@ -211,15 +212,9 @@ export async function addContractToGroup(
     groupSlugs: uniq([...(contract.groupSlugs ?? []), group.slug]),
     groupLinks: newGroupLinks,
   })
-
-  // create new contract document in groupContracts collection
-  const contractDoc = doc(groupContracts(group.id), contract.id)
-  await setDoc(contractDoc, {
-    contractId: contract.id,
-    createdTime: Date.now(),
-  })
 }
 
+// TODO: This doesn't check if the user has permission to do this
 export async function removeContractFromGroup(
   group: Group,
   contract: Contract
@@ -234,10 +229,6 @@ export async function removeContractFromGroup(
       groupLinks: newGroupLinks ?? [],
     })
   }
-
-  // delete the contract document in groupContracts collection
-  const contractDoc = doc(groupContracts(group.id), contract.id)
-  await deleteDoc(contractDoc)
 }
 
 export function getGroupLinkToDisplay(contract: Contract) {

web/pages/index.tsx

@@ -1,3 +1,6 @@
+import { useEffect } from 'react'
+import Router from 'next/router'
+
 import { Contract, getTrendingContracts } from 'web/lib/firebase/contracts'
 import { Page } from 'web/components/page'
 import { LandingPagePanel } from 'web/components/landing-page-panel'
@@ -6,6 +9,7 @@ import { ManifoldLogo } from 'web/components/nav/manifold-logo'
 import { redirectIfLoggedIn } from 'web/lib/firebase/server-auth'
 import { useSaveReferral } from 'web/hooks/use-save-referral'
 import { SEO } from 'web/components/SEO'
+import { useUser } from 'web/hooks/use-user'
 
 export const getServerSideProps = redirectIfLoggedIn('/home', async (_) => {
   const hotContracts = await getTrendingContracts()
@@ -16,6 +20,7 @@ export default function Home(props: { hotContracts: Contract[] }) {
   const { hotContracts } = props
 
   useSaveReferral()
+  useRedirectAfterLogin()
 
   return (
     <Page>
@@ -35,3 +40,13 @@ export default function Home(props: { hotContracts: Contract[] }) {
     </Page>
   )
 }
+
+const useRedirectAfterLogin = () => {
+  const user = useUser()
+
+  useEffect(() => {
+    if (user) {
+      Router.replace('/home')
+    }
+  }, [user])
+}