318 changed files with 6029 additions and 14190 deletions
--- a/.github/workflows/merge-main-into-main2.yml
+++ b/.github/workflows/merge-main-into-main2.yml
@ -1,17 +0,0 @@
-name: Merge main into main2 on every commit
-on:
-  push:
-    branches:
-      - 'main'
-jobs:
-  merge-branch:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@master
-
-      - name: Merge main -> main2
-        uses: devmasx/merge-branch@master
-        with:
-          type: now
-          target_branch: main2
-          github_token: ${{ github.token }}
--- a/common/.eslintrc.js
+++ b/common/.eslintrc.js
@ -26,7 +26,7 @@ module.exports = {
            caughtErrorsIgnorePattern: '^_',
          },
        ],
-        'unused-imports/no-unused-imports': 'warn',
+        'unused-imports/no-unused-imports': 'error',
      },
    },
  ],
--- a/common/add-liquidity.ts
+++ b/common/add-liquidity.ts
@ -1,4 +1,4 @@
-import { getCpmmLiquidity } from './calculate-cpmm'
+import { addCpmmLiquidity, getCpmmLiquidity } from './calculate-cpmm'
 import { CPMMContract } from './contract'
 import { LiquidityProvision } from './liquidity-provision'

@ -8,23 +8,25 @@ export const getNewLiquidityProvision = (
  contract: CPMMContract,
  newLiquidityProvisionId: string
 ) => {
-  const { pool, p, totalLiquidity, subsidyPool } = contract
+  const { pool, p, totalLiquidity } = contract

-  const liquidity = getCpmmLiquidity(pool, p)
+  const { newPool, newP } = addCpmmLiquidity(pool, p, amount)
+
+  const liquidity =
+    getCpmmLiquidity(newPool, newP) - getCpmmLiquidity(pool, newP)

  const newLiquidityProvision: LiquidityProvision = {
    id: newLiquidityProvisionId,
    userId: userId,
    contractId: contract.id,
    amount,
-    pool,
-    p,
+    pool: newPool,
+    p: newP,
    liquidity,
    createdTime: Date.now(),
  }

  const newTotalLiquidity = (totalLiquidity ?? 0) + amount
-  const newSubsidyPool = (subsidyPool ?? 0) + amount

-  return { newLiquidityProvision, newTotalLiquidity, newSubsidyPool }
+  return { newLiquidityProvision, newPool, newP, newTotalLiquidity }
 }
--- a/common/badge.ts
+++ b/common/badge.ts
@ -1,123 +0,0 @@
-import { User } from './user'
-
-export type Badge = {
-  type: BadgeTypes
-  createdTime: number
-  data: { [key: string]: any }
-  name: 'Proven Correct' | 'Streaker' | 'Market Creator'
-}
-
-export type BadgeTypes = 'PROVEN_CORRECT' | 'STREAKER' | 'MARKET_CREATOR'
-
-export type ProvenCorrectBadgeData = {
-  type: 'PROVEN_CORRECT'
-  data: {
-    contractSlug: string
-    contractCreatorUsername: string
-    contractTitle: string
-    commentId: string
-    betAmount: number
-  }
-}
-
-export type MarketCreatorBadgeData = {
-  type: 'MARKET_CREATOR'
-  data: {
-    totalContractsCreated: number
-  }
-}
-
-export type StreakerBadgeData = {
-  type: 'STREAKER'
-  data: {
-    totalBettingStreak: number
-  }
-}
-
-export type ProvenCorrectBadge = Badge & ProvenCorrectBadgeData
-export type StreakerBadge = Badge & StreakerBadgeData
-export type MarketCreatorBadge = Badge & MarketCreatorBadgeData
-
-export const MINIMUM_UNIQUE_BETTORS_FOR_PROVEN_CORRECT_BADGE = 5
-export const provenCorrectRarityThresholds = [1, 1000, 10000]
-const calculateProvenCorrectBadgeRarity = (badge: ProvenCorrectBadge) => {
-  const { betAmount } = badge.data
-  const thresholdArray = provenCorrectRarityThresholds
-  let i = thresholdArray.length - 1
-  while (i >= 0) {
-    if (betAmount >= thresholdArray[i]) {
-      return i + 1
-    }
-    i--
-  }
-  return 1
-}
-
-export const streakerBadgeRarityThresholds = [1, 50, 250]
-const calculateStreakerBadgeRarity = (badge: StreakerBadge) => {
-  const { totalBettingStreak } = badge.data
-  const thresholdArray = streakerBadgeRarityThresholds
-  let i = thresholdArray.length - 1
-  while (i >= 0) {
-    if (totalBettingStreak == thresholdArray[i]) {
-      return i + 1
-    }
-    i--
-  }
-  return 1
-}
-
-export const marketCreatorBadgeRarityThresholds = [1, 75, 300]
-const calculateMarketCreatorBadgeRarity = (badge: MarketCreatorBadge) => {
-  const { totalContractsCreated } = badge.data
-  const thresholdArray = marketCreatorBadgeRarityThresholds
-  let i = thresholdArray.length - 1
-  while (i >= 0) {
-    if (totalContractsCreated == thresholdArray[i]) {
-      return i + 1
-    }
-    i--
-  }
-  return 1
-}
-
-export type rarities = 'bronze' | 'silver' | 'gold'
-
-const rarityRanks: { [key: number]: rarities } = {
-  1: 'bronze',
-  2: 'silver',
-  3: 'gold',
-}
-
-export const calculateBadgeRarity = (badge: Badge) => {
-  switch (badge.type) {
-    case 'PROVEN_CORRECT':
-      return rarityRanks[
-        calculateProvenCorrectBadgeRarity(badge as ProvenCorrectBadge)
-      ]
-    case 'MARKET_CREATOR':
-      return rarityRanks[
-        calculateMarketCreatorBadgeRarity(badge as MarketCreatorBadge)
-      ]
-    case 'STREAKER':
-      return rarityRanks[calculateStreakerBadgeRarity(badge as StreakerBadge)]
-    default:
-      return rarityRanks[0]
-  }
-}
-
-export const getBadgesByRarity = (user: User | null | undefined) => {
-  const rarities: { [key in rarities]: number } = {
-    bronze: 0,
-    silver: 0,
-    gold: 0,
-  }
-  if (!user) return rarities
-  Object.values(user.achievements).map((value) => {
-    value.badges.map((badge) => {
-      rarities[calculateBadgeRarity(badge)] =
-        (rarities[calculateBadgeRarity(badge)] ?? 0) + 1
-    })
-  })
-  return rarities
-}
--- a/common/calculate-cpmm.ts
+++ b/common/calculate-cpmm.ts
@ -1,10 +1,11 @@
-import { groupBy, mapValues, sumBy } from 'lodash'
+import { sum, groupBy, mapValues, sumBy } from 'lodash'
 import { LimitBet } from './bet'

 import { CREATOR_FEE, Fees, LIQUIDITY_FEE, PLATFORM_FEE } from './fees'
 import { LiquidityProvision } from './liquidity-provision'
 import { computeFills } from './new-bet'
 import { binarySearch } from './util/algos'
+import { addObjects } from './util/object'

 export type CpmmState = {
  pool: { [outcome: string]: number }
@ -146,8 +147,7 @@ function calculateAmountToBuyShares(
  state: CpmmState,
  shares: number,
  outcome: 'YES' | 'NO',
-  unfilledBets: LimitBet[],
-  balanceByUserId: { [userId: string]: number }
+  unfilledBets: LimitBet[]
 ) {
  // Search for amount between bounds (0, shares).
  // Min share price is M$0, and max is M$1 each.
@ -157,8 +157,7 @@ function calculateAmountToBuyShares(
      amount,
      state,
      undefined,
-      unfilledBets,
-      balanceByUserId
+      unfilledBets
    )

    const totalShares = sumBy(takers, (taker) => taker.shares)
@ -170,8 +169,7 @@ export function calculateCpmmSale(
  state: CpmmState,
  shares: number,
  outcome: 'YES' | 'NO',
-  unfilledBets: LimitBet[],
-  balanceByUserId: { [userId: string]: number }
+  unfilledBets: LimitBet[]
 ) {
  if (Math.round(shares) < 0) {
    throw new Error('Cannot sell non-positive shares')
@ -182,17 +180,15 @@ export function calculateCpmmSale(
    state,
    shares,
    oppositeOutcome,
-    unfilledBets,
-    balanceByUserId
+    unfilledBets
  )

-  const { cpmmState, makers, takers, totalFees, ordersToCancel } = computeFills(
+  const { cpmmState, makers, takers, totalFees } = computeFills(
    oppositeOutcome,
    buyAmount,
    state,
    undefined,
-    unfilledBets,
-    balanceByUserId
+    unfilledBets
  )

  // Transform buys of opposite outcome into sells.
@ -215,7 +211,6 @@ export function calculateCpmmSale(
    fees: totalFees,
    makers,
    takers: saleTakers,
-    ordersToCancel,
  }
 }

@ -223,16 +218,9 @@ export function getCpmmProbabilityAfterSale(
  state: CpmmState,
  shares: number,
  outcome: 'YES' | 'NO',
-  unfilledBets: LimitBet[],
-  balanceByUserId: { [userId: string]: number }
+  unfilledBets: LimitBet[]
 ) {
-  const { cpmmState } = calculateCpmmSale(
-    state,
-    shares,
-    outcome,
-    unfilledBets,
-    balanceByUserId
-  )
+  const { cpmmState } = calculateCpmmSale(state, shares, outcome, unfilledBets)
  return getCpmmProbability(cpmmState.pool, cpmmState.p)
 }

@ -266,22 +254,48 @@ export function addCpmmLiquidity(
  return { newPool, liquidity, newP }
 }

-export function getCpmmLiquidityPoolWeights(liquidities: LiquidityProvision[]) {
-  const userAmounts = groupBy(liquidities, (w) => w.userId)
-  const totalAmount = sumBy(liquidities, (w) => w.amount)
+const calculateLiquidityDelta = (p: number) => (l: LiquidityProvision) => {
+  const oldLiquidity = getCpmmLiquidity(l.pool, p)

-  return mapValues(
-    userAmounts,
-    (amounts) => sumBy(amounts, (w) => w.amount) / totalAmount
+  const newPool = addObjects(l.pool, { YES: l.amount, NO: l.amount })
+  const newLiquidity = getCpmmLiquidity(newPool, p)
+
+  const liquidity = newLiquidity - oldLiquidity
+  return liquidity
+}
+
+export function getCpmmLiquidityPoolWeights(
+  state: CpmmState,
+  liquidities: LiquidityProvision[],
+  excludeAntes: boolean
+) {
+  const calcLiqudity = calculateLiquidityDelta(state.p)
+  const liquidityShares = liquidities.map(calcLiqudity)
+  const shareSum = sum(liquidityShares)
+
+  const weights = liquidityShares.map((shares, i) => ({
+    weight: shares / shareSum,
+    providerId: liquidities[i].userId,
+  }))
+
+  const includedWeights = excludeAntes
+    ? weights.filter((_, i) => !liquidities[i].isAnte)
+    : weights
+
+  const userWeights = groupBy(includedWeights, (w) => w.providerId)
+  const totalUserWeights = mapValues(userWeights, (userWeight) =>
+    sumBy(userWeight, (w) => w.weight)
  )
+  return totalUserWeights
 }

 export function getUserLiquidityShares(
  userId: string,
  state: CpmmState,
-  liquidities: LiquidityProvision[]
+  liquidities: LiquidityProvision[],
+  excludeAntes: boolean
 ) {
-  const weights = getCpmmLiquidityPoolWeights(liquidities)
+  const weights = getCpmmLiquidityPoolWeights(state, liquidities, excludeAntes)
  const userWeight = weights[userId] ?? 0

  return mapValues(state.pool, (shares) => userWeight * shares)
--- a/common/calculate-metrics.ts
+++ b/common/calculate-metrics.ts
@ -1,17 +1,9 @@
-import { Dictionary, groupBy, last, partition, sum, sumBy, uniq } from 'lodash'
-import { calculatePayout, getContractBetMetrics } from './calculate'
-import { Bet, LimitBet } from './bet'
-import {
-  Contract,
-  CPMMBinaryContract,
-  CPMMContract,
-  DPMContract,
-} from './contract'
+import { last, sortBy, sum, sumBy } from 'lodash'
+import { calculatePayout } from './calculate'
+import { Bet } from './bet'
+import { Contract } from './contract'
 import { PortfolioMetrics, User } from './user'
 import { DAY_MS } from './util/time'
-import { getBinaryCpmmBetInfo, getNewMultiBetInfo } from './new-bet'
-import { getCpmmProbability } from './calculate-cpmm'
-import { removeUndefinedProps } from './util/object'

 const computeInvestmentValue = (
  bets: Bet[],
@ -41,81 +33,13 @@ export const computeInvestmentValueCustomProb = (

    const betP = outcome === 'YES' ? p : 1 - p

-    const value = betP * shares
+    const payout = betP * shares
+    const value = payout - (bet.loanAmount ?? 0)
    if (isNaN(value)) return 0
    return value
  })
 }

-export const computeElasticity = (
-  bets: Bet[],
-  contract: Contract,
-  betAmount = 50
-) => {
-  const { mechanism, outcomeType } = contract
-  return mechanism === 'cpmm-1' &&
-    (outcomeType === 'BINARY' || outcomeType === 'PSEUDO_NUMERIC')
-    ? computeBinaryCpmmElasticity(bets, contract, betAmount)
-    : computeDpmElasticity(contract, betAmount)
-}
-
-export const computeBinaryCpmmElasticity = (
-  bets: Bet[],
-  contract: CPMMContract,
-  betAmount: number
-) => {
-  const limitBets = bets
-    .filter(
-      (b) =>
-        !b.isFilled &&
-        !b.isSold &&
-        !b.isRedemption &&
-        !b.sale &&
-        !b.isCancelled &&
-        b.limitProb !== undefined
-    )
-    .sort((a, b) => a.createdTime - b.createdTime) as LimitBet[]
-
-  const userIds = uniq(limitBets.map((b) => b.userId))
-  // Assume all limit orders are good.
-  const userBalances = Object.fromEntries(
-    userIds.map((id) => [id, Number.MAX_SAFE_INTEGER])
-  )
-
-  const { newPool: poolY, newP: pY } = getBinaryCpmmBetInfo(
-    'YES',
-    betAmount,
-    contract,
-    undefined,
-    limitBets,
-    userBalances
-  )
-  const resultYes = getCpmmProbability(poolY, pY)
-
-  const { newPool: poolN, newP: pN } = getBinaryCpmmBetInfo(
-    'NO',
-    betAmount,
-    contract,
-    undefined,
-    limitBets,
-    userBalances
-  )
-  const resultNo = getCpmmProbability(poolN, pN)
-
-  // handle AMM overflow
-  const safeYes = Number.isFinite(resultYes) ? resultYes : 1
-  const safeNo = Number.isFinite(resultNo) ? resultNo : 0
-
-  return safeYes - safeNo
-}
-
-export const computeDpmElasticity = (
-  contract: DPMContract,
-  betAmount: number
-) => {
-  return getNewMultiBetInfo('', 2 * betAmount, contract).newBet.probAfter
-}
-
 const computeTotalPool = (userContracts: Contract[], startTime = 0) => {
  const periodFilteredContracts = userContracts.filter(
    (contract) => contract.createdTime >= startTime
@ -199,9 +123,14 @@ export const calculateNewPortfolioMetrics = (
 }

 const calculateProfitForPeriod = (
-  startingPortfolio: PortfolioMetrics | undefined,
+  startTime: number,
+  descendingPortfolio: PortfolioMetrics[],
  currentProfit: number
 ) => {
+  const startingPortfolio = descendingPortfolio.find(
+    (p) => p.timestamp < startTime
+  )
+
  if (startingPortfolio === undefined) {
    return currentProfit
  }
@ -216,100 +145,33 @@ export const calculatePortfolioProfit = (portfolio: PortfolioMetrics) => {
 }

 export const calculateNewProfit = (
-  portfolioHistory: Record<
-    'current' | 'day' | 'week' | 'month',
-    PortfolioMetrics | undefined
-  >,
+  portfolioHistory: PortfolioMetrics[],
  newPortfolio: PortfolioMetrics
 ) => {
  const allTimeProfit = calculatePortfolioProfit(newPortfolio)
+  const descendingPortfolio = sortBy(
+    portfolioHistory,
+    (p) => p.timestamp
+  ).reverse()

  const newProfit = {
-    daily: calculateProfitForPeriod(portfolioHistory.day, allTimeProfit),
-    weekly: calculateProfitForPeriod(portfolioHistory.week, allTimeProfit),
-    monthly: calculateProfitForPeriod(portfolioHistory.month, allTimeProfit),
+    daily: calculateProfitForPeriod(
+      Date.now() - 1 * DAY_MS,
+      descendingPortfolio,
+      allTimeProfit
+    ),
+    weekly: calculateProfitForPeriod(
+      Date.now() - 7 * DAY_MS,
+      descendingPortfolio,
+      allTimeProfit
+    ),
+    monthly: calculateProfitForPeriod(
+      Date.now() - 30 * DAY_MS,
+      descendingPortfolio,
+      allTimeProfit
+    ),
    allTime: allTimeProfit,
  }

  return newProfit
 }
-
-export const calculateMetricsByContract = (
-  bets: Bet[],
-  contractsById: Dictionary<Contract>
-) => {
-  const betsByContract = groupBy(bets, (bet) => bet.contractId)
-  const unresolvedContracts = Object.keys(betsByContract)
-    .map((cid) => contractsById[cid])
-    .filter((c) => c && !c.isResolved)
-
-  return unresolvedContracts.map((c) => {
-    const bets = betsByContract[c.id] ?? []
-    const current = getContractBetMetrics(c, bets)
-
-    let periodMetrics
-    if (c.mechanism === 'cpmm-1' && c.outcomeType === 'BINARY') {
-      const periods = ['day', 'week', 'month'] as const
-      periodMetrics = Object.fromEntries(
-        periods.map((period) => [
-          period,
-          calculatePeriodProfit(c, bets, period),
-        ])
-      )
-    }
-
-    return removeUndefinedProps({
-      contractId: c.id,
-      ...current,
-      from: periodMetrics,
-    })
-  })
-}
-
-export type ContractMetrics = ReturnType<
-  typeof calculateMetricsByContract
->[number]
-
-const calculatePeriodProfit = (
-  contract: CPMMBinaryContract,
-  bets: Bet[],
-  period: 'day' | 'week' | 'month'
-) => {
-  const days = period === 'day' ? 1 : period === 'week' ? 7 : 30
-  const fromTime = Date.now() - days * DAY_MS
-  const [previousBets, recentBets] = partition(
-    bets,
-    (b) => b.createdTime < fromTime
-  )
-
-  const prevProb = contract.prob - contract.probChanges[period]
-  const prob = contract.resolutionProbability
-    ? contract.resolutionProbability
-    : contract.prob
-
-  const previousBetsValue = computeInvestmentValueCustomProb(
-    previousBets,
-    contract,
-    prevProb
-  )
-  const currentBetsValue = computeInvestmentValueCustomProb(
-    previousBets,
-    contract,
-    prob
-  )
-
-  const { profit: recentProfit, invested: recentInvested } =
-    getContractBetMetrics(contract, recentBets)
-
-  const profit = currentBetsValue - previousBetsValue + recentProfit
-  const invested = previousBetsValue + recentInvested
-  const profitPercent = invested === 0 ? 0 : 100 * (profit / invested)
-
-  return {
-    profit,
-    profitPercent,
-    invested,
-    prevValue: previousBetsValue,
-    value: currentBetsValue,
-  }
-}
--- a/common/calculate.ts
+++ b/common/calculate.ts
@ -78,8 +78,7 @@ export function calculateShares(
 export function calculateSaleAmount(
  contract: Contract,
  bet: Bet,
-  unfilledBets: LimitBet[],
-  balanceByUserId: { [userId: string]: number }
+  unfilledBets: LimitBet[]
 ) {
  return contract.mechanism === 'cpmm-1' &&
    (contract.outcomeType === 'BINARY' ||
@ -88,8 +87,7 @@ export function calculateSaleAmount(
        contract,
        Math.abs(bet.shares),
        bet.outcome as 'YES' | 'NO',
-        unfilledBets,
-        balanceByUserId
+        unfilledBets
      ).saleValue
    : calculateDpmSaleAmount(contract, bet)
 }
@ -104,16 +102,14 @@ export function getProbabilityAfterSale(
  contract: Contract,
  outcome: string,
  shares: number,
-  unfilledBets: LimitBet[],
-  balanceByUserId: { [userId: string]: number }
+  unfilledBets: LimitBet[]
 ) {
  return contract.mechanism === 'cpmm-1'
    ? getCpmmProbabilityAfterSale(
        contract,
        shares,
        outcome as 'YES' | 'NO',
-        unfilledBets,
-        balanceByUserId
+        unfilledBets
      )
    : getDpmProbabilityAfterSale(contract.totalShares, outcome, shares)
 }
@ -178,8 +174,6 @@ function getDpmInvested(yourBets: Bet[]) {
  })
 }

-export type ContractBetMetrics = ReturnType<typeof getContractBetMetrics>
-
 export function getContractBetMetrics(contract: Contract, yourBets: Bet[]) {
  const { resolution } = contract
  const isCpmm = contract.mechanism === 'cpmm-1'
@ -216,8 +210,9 @@ export function getContractBetMetrics(contract: Contract, yourBets: Bet[]) {
    }
  }

+  const netPayout = payout - loan
  const profit = payout + saleValue + redeemed - totalInvested
-  const profitPercent = totalInvested === 0 ? 0 : (profit / totalInvested) * 100
+  const profitPercent = (profit / totalInvested) * 100

  const invested = isCpmm ? getCpmmInvested(yourBets) : getDpmInvested(yourBets)
  const hasShares = Object.values(totalShares).some(
@ -226,8 +221,8 @@ export function getContractBetMetrics(contract: Contract, yourBets: Bet[]) {

  return {
    invested,
-    loan,
    payout,
+    netPayout,
    profit,
    profitPercent,
    totalShares,
@ -238,8 +233,8 @@ export function getContractBetMetrics(contract: Contract, yourBets: Bet[]) {
 export function getContractBetNullMetrics() {
  return {
    invested: 0,
-    loan: 0,
    payout: 0,
+    netPayout: 0,
    profit: 0,
    profitPercent: 0,
    totalShares: {} as { [outcome: string]: number },
--- a/common/charity.ts
+++ b/common/charity.ts
@ -589,15 +589,6 @@ CaRLA uses legal advocacy and education to ensure all cities comply with their o

 In addition to housing impact litigation, we provide free legal aid, education and workshops, counseling and advocacy to advocates, homeowners, small developers, and city and state government officials.`,
  },
-  {
-    name: 'Mriya',
-    website: 'https://mriya-ua.org/',
-    photo:
-      'https://firebasestorage.googleapis.com/v0/b/mantic-markets.appspot.com/o/user-images%2Fdefault%2Fci2h3hStFM.47?alt=media&token=0d2cdc3d-e4d8-4f5e-8f23-4a586b6ff637',
-    preview: 'Donate supplies to soldiers in Ukraine',
-    description:
-      'Donate supplies to soldiers in Ukraine, including tourniquets and plate carriers.',
-  },
 ].map((charity) => {
  const slug = charity.name.toLowerCase().replace(/\s/g, '-')
  return {
--- a/common/comment.ts
+++ b/common/comment.ts
@ -18,7 +18,6 @@ export type Comment<T extends AnyCommentType = AnyCommentType> = {
  userName: string
  userUsername: string
  userAvatarUrl?: string
-  bountiesAwarded?: number
 } & T

 export type OnContract = {
--- a/common/contract-details.ts
+++ b/common/contract-details.ts
@ -30,7 +30,7 @@ export function contractTextDetails(contract: Contract) {
  const { closeTime, groupLinks } = contract
  const { createdDate, resolvedDate, volumeLabel } = contractMetrics(contract)

-  const groupHashtags = groupLinks?.map((g) => `#${g.name.replace(/ /g, '')}`)
+  const groupHashtags = groupLinks?.slice(0, 5).map((g) => `#${g.name}`)

  return (
    `${resolvedDate ? `${createdDate} - ${resolvedDate}` : createdDate}` +
--- a/common/contract.ts
+++ b/common/contract.ts
@ -10,7 +10,6 @@ export type AnyOutcomeType =
  | PseudoNumeric
  | FreeResponse
  | Numeric
-
 export type AnyContractType =
  | (CPMM & Binary)
  | (CPMM & PseudoNumeric)
@ -50,7 +49,6 @@ export type Contract<T extends AnyContractType = AnyContractType> = {
  volume: number
  volume24Hours: number
  volume7Days: number
-  elasticity: number

  collectedFees: Fees

@ -64,9 +62,6 @@ export type Contract<T extends AnyContractType = AnyContractType> = {
  featuredOnHomeRank?: number
  likedByUserIds?: string[]
  likedByUserCount?: number
-  flaggedByUsernames?: string[]
-  openCommentBounties?: number
-  unlistedById?: string
 } & T

 export type BinaryContract = Contract & Binary
@ -92,8 +87,7 @@ export type CPMM = {
  mechanism: 'cpmm-1'
  pool: { [outcome: string]: number }
  p: number // probability constant in y^p * n^(1-p) = k
-  totalLiquidity: number // for historical reasons, this the total subsidy amount added in M$
-  subsidyPool: number // current value of subsidy pool in M$
+  totalLiquidity: number // in M$
  prob: number
  probChanges: {
    day: number
--- a/common/economy.ts
+++ b/common/economy.ts
@ -11,10 +11,7 @@ export const REFERRAL_AMOUNT = econ?.REFERRAL_AMOUNT ?? 250

 export const UNIQUE_BETTOR_BONUS_AMOUNT = econ?.UNIQUE_BETTOR_BONUS_AMOUNT ?? 10
 export const BETTING_STREAK_BONUS_AMOUNT =
-  econ?.BETTING_STREAK_BONUS_AMOUNT ?? 5
-export const BETTING_STREAK_BONUS_MAX = econ?.BETTING_STREAK_BONUS_MAX ?? 25
+  econ?.BETTING_STREAK_BONUS_AMOUNT ?? 10
+export const BETTING_STREAK_BONUS_MAX = econ?.BETTING_STREAK_BONUS_MAX ?? 50
 export const BETTING_STREAK_RESET_HOUR = econ?.BETTING_STREAK_RESET_HOUR ?? 7
 export const FREE_MARKETS_PER_USER_MAX = econ?.FREE_MARKETS_PER_USER_MAX ?? 5
-export const COMMENT_BOUNTY_AMOUNT = econ?.COMMENT_BOUNTY_AMOUNT ?? 250
-
-export const UNIQUE_BETTOR_LIQUIDITY = 20
--- a/common/envs/dev.ts
+++ b/common/envs/dev.ts
@ -16,6 +16,6 @@ export const DEV_CONFIG: EnvConfig = {
  cloudRunId: 'w3txbmd3ba',
  cloudRunRegion: 'uc',
  amplitudeApiKey: 'fd8cbfd964b9a205b8678a39faae71b3',
-  twitchBotEndpoint: 'https://dev-twitch-bot.manifold.markets',
-  sprigEnvironmentId: 'Tu7kRZPm7daP',
+  // this is Phil's deployment
+  twitchBotEndpoint: 'https://king-prawn-app-5btyw.ondigitalocean.app',
 }
--- a/common/envs/prod.ts
+++ b/common/envs/prod.ts
@ -3,7 +3,6 @@ export type EnvConfig = {
  firebaseConfig: FirebaseConfig
  amplitudeApiKey?: string
  twitchBotEndpoint?: string
-  sprigEnvironmentId?: string

  // IDs for v2 cloud functions -- find these by deploying a cloud function and
  // examining the URL, https://[name]-[cloudRunId]-[cloudRunRegion].a.run.app
@ -41,7 +40,6 @@ export type Economy = {
  BETTING_STREAK_BONUS_MAX?: number
  BETTING_STREAK_RESET_HOUR?: number
  FREE_MARKETS_PER_USER_MAX?: number
-  COMMENT_BOUNTY_AMOUNT?: number
 }

 type FirebaseConfig = {
@ -58,7 +56,6 @@ type FirebaseConfig = {
 export const PROD_CONFIG: EnvConfig = {
  domain: 'manifold.markets',
  amplitudeApiKey: '2d6509fd4185ebb8be29709842752a15',
-  sprigEnvironmentId: 'sQcrq9TDqkib',

  firebaseConfig: {
    apiKey: 'AIzaSyDp3J57vLeAZCzxLD-vcPaGIkAmBoGOSYw',
@ -70,7 +67,7 @@ export const PROD_CONFIG: EnvConfig = {
    appId: '1:128925704902:web:f61f86944d8ffa2a642dc7',
    measurementId: 'G-SSFK1Q138D',
  },
-  twitchBotEndpoint: 'https://twitch-bot.manifold.markets',
+  twitchBotEndpoint: 'https://twitch-bot-nggbo3neva-uc.a.run.app',
  cloudRunId: 'nggbo3neva',
  cloudRunRegion: 'uc',
  adminEmails: [
--- a/common/fees.ts
+++ b/common/fees.ts
@ -1,5 +1,3 @@
-export const FLAT_TRADE_FEE = 0.1 // M$0.1
-
 export const PLATFORM_FEE = 0
 export const CREATOR_FEE = 0
 export const LIQUIDITY_FEE = 0
--- a/common/globalConfig.ts
+++ b/common/globalConfig.ts
@ -1,3 +0,0 @@
-export type GlobalConfig = {
-  pinnedItems: { itemId: string; type: 'post' | 'contract' }[]
-}
--- a/common/group.ts
+++ b/common/group.ts
@ -23,7 +23,6 @@ export type Group = {
      score: number
    }[]
  }
-  pinnedItems: { itemId: string; type: 'post' | 'contract' }[]
 }

 export const MAX_GROUP_NAME_LENGTH = 75
@ -39,4 +38,3 @@ export type GroupLink = {
  createdTime: number
  userId?: string
 }
-export type GroupContractDoc = { contractId: string; createdTime: number }
--- a/common/like.ts
+++ b/common/like.ts
@ -1,9 +1,8 @@
 export type Like = {
  id: string // will be id of the object liked, i.e. contract.id
  userId: string
-  type: 'contract' | 'post'
+  type: 'contract'
  createdTime: number
  tipTxnId?: string // only holds most recent tip txn id
 }
-export const LIKE_TIP_AMOUNT = 10
-export const TIP_UNDO_DURATION = 2000
+export const LIKE_TIP_AMOUNT = 5
--- a/common/new-bet.ts
+++ b/common/new-bet.ts
@ -17,7 +17,8 @@ import {
 import {
  CPMMBinaryContract,
  DPMBinaryContract,
-  DPMContract,
+  FreeResponseContract,
+  MultipleChoiceContract,
  NumericContract,
  PseudoNumericContract,
 } from './contract'
@ -143,8 +144,7 @@ export const computeFills = (
  betAmount: number,
  state: CpmmState,
  limitProb: number | undefined,
-  unfilledBets: LimitBet[],
-  balanceByUserId: { [userId: string]: number }
+  unfilledBets: LimitBet[]
 ) => {
  if (isNaN(betAmount)) {
    throw new Error('Invalid bet amount: ${betAmount}')
@ -166,12 +166,10 @@ export const computeFills = (
    shares: number
    timestamp: number
  }[] = []
-  const ordersToCancel: LimitBet[] = []

  let amount = betAmount
  let cpmmState = { pool: state.pool, p: state.p }
  let totalFees = noFees
-  const currentBalanceByUserId = { ...balanceByUserId }

  let i = 0
  while (true) {
@ -188,20 +186,9 @@ export const computeFills = (
      takers.push(taker)
    } else {
      // Matched against bet.
-      i++
-      const { userId } = maker.bet
-      const makerBalance = currentBalanceByUserId[userId]
-
-      if (floatingGreaterEqual(makerBalance, maker.amount)) {
-        currentBalanceByUserId[userId] = makerBalance - maker.amount
-      } else {
-        // Insufficient balance. Cancel maker bet.
-        ordersToCancel.push(maker.bet)
-        continue
-      }
-
      takers.push(taker)
      makers.push(maker)
+      i++
    }

    amount -= taker.amount
@ -209,7 +196,7 @@ export const computeFills = (
    if (floatingEqual(amount, 0)) break
  }

-  return { takers, makers, totalFees, cpmmState, ordersToCancel }
+  return { takers, makers, totalFees, cpmmState }
 }

 export const getBinaryCpmmBetInfo = (
@ -217,17 +204,15 @@ export const getBinaryCpmmBetInfo = (
  betAmount: number,
  contract: CPMMBinaryContract | PseudoNumericContract,
  limitProb: number | undefined,
-  unfilledBets: LimitBet[],
-  balanceByUserId: { [userId: string]: number }
+  unfilledBets: LimitBet[]
 ) => {
  const { pool, p } = contract
-  const { takers, makers, cpmmState, totalFees, ordersToCancel } = computeFills(
+  const { takers, makers, cpmmState, totalFees } = computeFills(
    outcome,
    betAmount,
    { pool, p },
    limitProb,
-    unfilledBets,
-    balanceByUserId
+    unfilledBets
  )
  const probBefore = getCpmmProbability(contract.pool, contract.p)
  const probAfter = getCpmmProbability(cpmmState.pool, cpmmState.p)
@ -262,7 +247,6 @@ export const getBinaryCpmmBetInfo = (
    newP: cpmmState.p,
    newTotalLiquidity,
    makers,
-    ordersToCancel,
  }
 }

@ -271,16 +255,14 @@ export const getBinaryBetStats = (
  betAmount: number,
  contract: CPMMBinaryContract | PseudoNumericContract,
  limitProb: number,
-  unfilledBets: LimitBet[],
-  balanceByUserId: { [userId: string]: number }
+  unfilledBets: LimitBet[]
 ) => {
  const { newBet } = getBinaryCpmmBetInfo(
    outcome,
    betAmount ?? 0,
    contract,
    limitProb,
-    unfilledBets,
-    balanceByUserId
+    unfilledBets as LimitBet[]
  )
  const remainingMatched =
    ((newBet.orderAmount ?? 0) - newBet.amount) /
@ -343,7 +325,7 @@ export const getNewBinaryDpmBetInfo = (
 export const getNewMultiBetInfo = (
  outcome: string,
  amount: number,
-  contract: DPMContract
+  contract: FreeResponseContract | MultipleChoiceContract
 ) => {
  const { pool, totalShares, totalBets } = contract

--- a/common/new-contract.ts
+++ b/common/new-contract.ts
@ -12,6 +12,7 @@ import {
  visibility,
 } from './contract'
 import { User } from './user'
+import { parseTags, richTextToString } from './util/parse'
 import { removeUndefinedProps } from './util/object'
 import { JSONContent } from '@tiptap/core'

@ -37,6 +38,15 @@ export function getNewContract(
  answers: string[],
  visibility: visibility
 ) {
+  const tags = parseTags(
+    [
+      question,
+      richTextToString(description),
+      ...extraTags.map((tag) => `#${tag}`),
+    ].join(' ')
+  )
+  const lowercaseTags = tags.map((tag) => tag.toLowerCase())
+
  const propsByOutcomeType =
    outcomeType === 'BINARY'
      ? getBinaryCpmmProps(initialProb, ante) // getBinaryDpmProps(initialProb, ante)
@ -60,10 +70,9 @@ export function getNewContract(

    question: question.trim(),
    description,
-    tags: [],
-    lowercaseTags: [],
+    tags,
+    lowercaseTags,
    visibility,
-    unlistedById: visibility === 'unlisted' ? creator.id : undefined,
    isResolved: false,
    createdTime: Date.now(),
    closeTime,
@ -71,7 +80,6 @@ export function getNewContract(
    volume: 0,
    volume24Hours: 0,
    volume7Days: 0,
-    elasticity: propsByOutcomeType.mechanism === 'cpmm-1' ? 0.38 : 0.75,

    collectedFees: {
      creatorFee: 0,
@ -112,7 +120,6 @@ const getBinaryCpmmProps = (initialProb: number, ante: number) => {
    mechanism: 'cpmm-1',
    outcomeType: 'BINARY',
    totalLiquidity: ante,
-    subsidyPool: 0,
    initialProbability: p,
    p,
    pool: pool,
--- a/common/notification.ts
+++ b/common/notification.ts
@ -4,7 +4,7 @@ export type Notification = {
  id: string
  userId: string
  reasonText?: string
-  reason?: notification_reason_types | notification_preference
+  reason?: notification_reason_types
  createdTime: number
  viewTime?: number
  isSeen: boolean
@ -46,7 +46,6 @@ export type notification_source_types =
  | 'loan'
  | 'like'
  | 'tip_and_like'
-  | 'badge'

 export type notification_source_update_types =
  | 'created'
@ -97,7 +96,6 @@ type notification_descriptions = {
  [key in notification_preference]: {
    simple: string
    detailed: string
-    necessary?: boolean
  }
 }
 export const NOTIFICATION_DESCRIPTIONS: notification_descriptions = {
@ -118,8 +116,8 @@ export const NOTIFICATION_DESCRIPTIONS: notification_descriptions = {
    detailed: "Only answers by market creator on markets you're watching",
  },
  betting_streaks: {
-    simple: `For prediction streaks`,
-    detailed: `Bonuses for predictions made over consecutive days (Prediction streaks)})`,
+    simple: 'For predictions made over consecutive days',
+    detailed: 'Bonuses for predictions made over consecutive days',
  },
  comments_by_followed_users_on_watched_markets: {
    simple: 'Only comments by users you follow',
@ -161,8 +159,8 @@ export const NOTIFICATION_DESCRIPTIONS: notification_descriptions = {
    detailed: 'Large changes in probability on markets that you watch',
  },
  profit_loss_updates: {
-    simple: 'Weekly portfolio updates',
-    detailed: 'Weekly portfolio updates',
+    simple: 'Weekly profit and loss updates',
+    detailed: 'Weekly profit and loss updates',
  },
  referral_bonuses: {
    simple: 'For referring new users',
@ -210,9 +208,8 @@ export const NOTIFICATION_DESCRIPTIONS: notification_descriptions = {
    detailed: 'Bonuses for unique predictors on your markets',
  },
  your_contract_closed: {
-    simple: 'Your market has closed and you need to resolve it (necessary)',
-    detailed: 'Your market has closed and you need to resolve it (necessary)',
-    necessary: true,
+    simple: 'Your market has closed and you need to resolve it',
+    detailed: 'Your market has closed and you need to resolve it',
  },
  all_comments_on_watched_markets: {
    simple: 'All new comments',
@ -238,15 +235,6 @@ export const NOTIFICATION_DESCRIPTIONS: notification_descriptions = {
    simple: `Only on markets you're invested in`,
    detailed: `Answers on markets that you're watching and that you're invested in`,
  },
-  badges_awarded: {
-    simple: 'New badges awarded',
-    detailed: 'New badges you have earned',
-  },
-  opt_out_all: {
-    simple: 'Opt out of all notifications (excludes when your markets close)',
-    detailed:
-      'Opt out of all notifications excluding your own market closure notifications',
-  },
 }

 export type BettingStreakData = {
--- a/common/package.json
+++ b/common/package.json
@ -8,13 +8,11 @@
  },
  "sideEffects": false,
  "dependencies": {
-    "@tiptap/core": "2.0.0-beta.199",
-    "@tiptap/extension-image": "2.0.0-beta.199",
-    "@tiptap/extension-link": "2.0.0-beta.199",
-    "@tiptap/extension-mention": "2.0.0-beta.199",
-    "@tiptap/html": "2.0.0-beta.199",
-    "@tiptap/starter-kit": "2.0.0-beta.199",
-    "@tiptap/suggestion": "2.0.0-beta.199",
+    "@tiptap/core": "2.0.0-beta.182",
+    "@tiptap/extension-image": "2.0.0-beta.30",
+    "@tiptap/extension-link": "2.0.0-beta.43",
+    "@tiptap/extension-mention": "2.0.0-beta.102",
+    "@tiptap/starter-kit": "2.0.0-beta.191",
    "lodash": "4.17.21"
  },
  "devDependencies": {
--- a/common/payouts-fixed.ts
+++ b/common/payouts-fixed.ts
@ -1,3 +1,4 @@
+
 import { Bet } from './bet'
 import { getProbability } from './calculate'
 import { getCpmmLiquidityPoolWeights } from './calculate-cpmm'
@ -55,11 +56,10 @@ export const getLiquidityPoolPayouts = (
  outcome: string,
  liquidities: LiquidityProvision[]
 ) => {
-  const { pool, subsidyPool } = contract
-  const finalPool = pool[outcome] + (subsidyPool ?? 0)
-  if (finalPool < 1e-3) return []
+  const { pool } = contract
+  const finalPool = pool[outcome]

-  const weights = getCpmmLiquidityPoolWeights(liquidities)
+  const weights = getCpmmLiquidityPoolWeights(contract, liquidities, false)

  return Object.entries(weights).map(([providerId, weight]) => ({
    userId: providerId,
@ -95,11 +95,10 @@ export const getLiquidityPoolProbPayouts = (
  p: number,
  liquidities: LiquidityProvision[]
 ) => {
-  const { pool, subsidyPool } = contract
-  const finalPool = p * pool.YES + (1 - p) * pool.NO + (subsidyPool ?? 0)
-  if (finalPool < 1e-3) return []
+  const { pool } = contract
+  const finalPool = p * pool.YES + (1 - p) * pool.NO

-  const weights = getCpmmLiquidityPoolWeights(liquidities)
+  const weights = getCpmmLiquidityPoolWeights(contract, liquidities, false)

  return Object.entries(weights).map(([providerId, weight]) => ({
    userId: providerId,
--- a/common/post.ts
+++ b/common/post.ts
@ -3,27 +3,10 @@ import { JSONContent } from '@tiptap/core'
 export type Post = {
  id: string
  title: string
-  subtitle: string
  content: JSONContent
  creatorId: string // User id
  createdTime: number
  slug: string
-
-  // denormalized user fields
-  creatorName: string
-  creatorUsername: string
-  creatorAvatarUrl?: string
-
-  likedByUserIds?: string[]
-  likedByUserCount?: number
-}
-
-export type DateDoc = Post & {
-  bounty: number
-  birthday: number
-  type: 'date-doc'
-  contractSlug: string
 }

 export const MAX_POST_TITLE_LENGTH = 480
-export const MAX_POST_SUBTITLE_LENGTH = 480
--- a/common/scoring.ts
+++ b/common/scoring.ts
@ -1,9 +1,8 @@
-import { groupBy, sumBy, mapValues, keyBy, sortBy } from 'lodash'
+import { groupBy, sumBy, mapValues } from 'lodash'

 import { Bet } from './bet'
-import { getContractBetMetrics, resolvedPayout } from './calculate'
+import { getContractBetMetrics } from './calculate'
 import { Contract } from './contract'
-import { ContractComment } from './comment'

 export function scoreCreators(contracts: Contract[]) {
  const creatorScore = mapValues(
@ -31,11 +30,8 @@ export function scoreTraders(contracts: Contract[], bets: Bet[][]) {
 }

 export function scoreUsersByContract(contract: Contract, bets: Bet[]) {
-  const betsByUser = groupBy(bets, (bet) => bet.userId)
-  return mapValues(
-    betsByUser,
-    (bets) => getContractBetMetrics(contract, bets).profit
-  )
+  const betsByUser = groupBy(bets, bet => bet.userId)
+  return mapValues(betsByUser, bets => getContractBetMetrics(contract, bets).profit)
 }

 export function addUserScores(
@ -47,47 +43,3 @@ export function addUserScores(
    dest[userId] += score
  }
 }
-
-export function scoreCommentorsAndBettors(
-  contract: Contract,
-  bets: Bet[],
-  comments: ContractComment[]
-) {
-  const commentsById = keyBy(comments, 'id')
-  const betsById = keyBy(bets, 'id')
-
-  // If 'id2' is the sale of 'id1', both are logged with (id2 - id1) of profit
-  // Otherwise, we record the profit at resolution time
-  const profitById: Record<string, number> = {}
-  for (const bet of bets) {
-    if (bet.sale) {
-      const originalBet = betsById[bet.sale.betId]
-      const profit = bet.sale.amount - originalBet.amount
-      profitById[bet.id] = profit
-      profitById[originalBet.id] = profit
-    } else {
-      profitById[bet.id] = resolvedPayout(contract, bet) - bet.amount
-    }
-  }
-
-  // Now find the betId with the highest profit
-  const topBetId = sortBy(bets, (b) => -profitById[b.id])[0]?.id
-  const topBettor = betsById[topBetId]?.userName
-
-  // And also the commentId of the comment with the highest profit
-  const topCommentId = sortBy(
-    comments,
-    (c) => c.betId && -profitById[c.betId]
-  )[0]?.id
-  const topCommentBetId = commentsById[topCommentId]?.betId
-
-  return {
-    topCommentId,
-    topBetId,
-    topBettor,
-    profitById,
-    commentsById,
-    betsById,
-    topCommentBetId,
-  }
-}
--- a/common/sell-bet.ts
+++ b/common/sell-bet.ts
@ -84,17 +84,15 @@ export const getCpmmSellBetInfo = (
  outcome: 'YES' | 'NO',
  contract: CPMMContract,
  unfilledBets: LimitBet[],
-  balanceByUserId: { [userId: string]: number },
  loanPaid: number
 ) => {
  const { pool, p } = contract

-  const { saleValue, cpmmState, fees, makers, takers, ordersToCancel } = calculateCpmmSale(
+  const { saleValue, cpmmState, fees, makers, takers } = calculateCpmmSale(
    contract,
    shares,
    outcome,
-    unfilledBets,
-    balanceByUserId,
+    unfilledBets
  )

  const probBefore = getCpmmProbability(pool, p)
@ -136,6 +134,5 @@ export const getCpmmSellBetInfo = (
    fees,
    makers,
    takers,
-    ordersToCancel
  }
 }
--- a/common/txn.ts
+++ b/common/txn.ts
@ -8,7 +8,6 @@ type AnyTxnType =
  | UniqueBettorBonus
  | BettingStreakBonus
  | CancelUniqueBettorBonus
-  | CommentBountyRefund
 type SourceType = 'USER' | 'CONTRACT' | 'CHARITY' | 'BANK'

 export type Txn<T extends AnyTxnType = AnyTxnType> = {
@ -32,8 +31,6 @@ export type Txn<T extends AnyTxnType = AnyTxnType> = {
    | 'UNIQUE_BETTOR_BONUS'
    | 'BETTING_STREAK_BONUS'
    | 'CANCEL_UNIQUE_BETTOR_BONUS'
-    | 'COMMENT_BOUNTY'
-    | 'REFUND_COMMENT_BOUNTY'

  // Any extra data
  data?: { [key: string]: any }
@ -101,34 +98,6 @@ type CancelUniqueBettorBonus = {
  }
 }

-type CommentBountyDeposit = {
-  fromType: 'USER'
-  toType: 'BANK'
-  category: 'COMMENT_BOUNTY'
-  data: {
-    contractId: string
-  }
-}
-
-type CommentBountyWithdrawal = {
-  fromType: 'BANK'
-  toType: 'USER'
-  category: 'COMMENT_BOUNTY'
-  data: {
-    contractId: string
-    commentId: string
-  }
-}
-
-type CommentBountyRefund = {
-  fromType: 'BANK'
-  toType: 'USER'
-  category: 'REFUND_COMMENT_BOUNTY'
-  data: {
-    contractId: string
-  }
-}
-
 export type DonationTxn = Txn & Donation
 export type TipTxn = Txn & Tip
 export type ManalinkTxn = Txn & Manalink
@ -136,5 +105,3 @@ export type ReferralTxn = Txn & Referral
 export type BettingStreakBonusTxn = Txn & BettingStreakBonus
 export type UniqueBettorBonusTxn = Txn & UniqueBettorBonus
 export type CancelUniqueBettorBonusTxn = Txn & CancelUniqueBettorBonus
-export type CommentBountyDepositTxn = Txn & CommentBountyDeposit
-export type CommentBountyWithdrawalTxn = Txn & CommentBountyWithdrawal
--- a/common/user-notification-preferences.ts
+++ b/common/user-notification-preferences.ts
@ -53,9 +53,6 @@ export type notification_preferences = {
  profit_loss_updates: notification_destination_types[]
  onboarding_flow: notification_destination_types[]
  thank_you_for_purchases: notification_destination_types[]
-  badges_awarded: notification_destination_types[]
-  opt_out_all: notification_destination_types[]
-  // When adding a new notification preference, use add-new-notification-preference.ts to existing users
 }

 export const getDefaultNotificationPreferences = (
@ -68,7 +65,7 @@ export const getDefaultNotificationPreferences = (
    const email = noEmails ? undefined : emailIf ? 'email' : undefined
    return filterDefined([browser, email]) as notification_destination_types[]
  }
-  const defaults: notification_preferences = {
+  return {
    // Watched Markets
    all_comments_on_watched_markets: constructPref(true, false),
    all_answers_on_watched_markets: constructPref(true, false),
@ -110,7 +107,7 @@ export const getDefaultNotificationPreferences = (
    loan_income: constructPref(true, false),
    betting_streaks: constructPref(true, false),
    referral_bonuses: constructPref(true, true),
-    unique_bettors_on_your_contract: constructPref(true, true),
+    unique_bettors_on_your_contract: constructPref(true, false),
    tipped_comments_on_watched_markets: constructPref(true, true),
    tips_on_your_markets: constructPref(true, true),
    limit_order_fills: constructPref(true, false),
@ -124,11 +121,7 @@ export const getDefaultNotificationPreferences = (
    probability_updates_on_watched_markets: constructPref(true, false),
    thank_you_for_purchases: constructPref(false, false),
    onboarding_flow: constructPref(false, false),
-
-    opt_out_all: [],
-    badges_awarded: constructPref(true, false),
-  }
-  return defaults
+  } as notification_preferences
 }

 // Adding a new key:value here is optional, you can just use a key of notification_subscription_types
@ -179,8 +172,6 @@ export const getNotificationDestinationsForUser = (
  reason: notification_reason_types | notification_preference
 ) => {
  const notificationSettings = privateUser.notificationPreferences
-  const unsubscribeEndpoint = getFunctionUrl('unsubscribe')
-  try {
  let destinations
  let subscriptionType: notification_preference | undefined
  if (Object.keys(notificationSettings).includes(reason)) {
@ -193,30 +184,11 @@ export const getNotificationDestinationsForUser = (
      ? notificationSettings[subscriptionType]
      : []
  }
-    const optOutOfAllSettings = notificationSettings['opt_out_all']
-    // Your market closure notifications are high priority, opt-out doesn't affect their delivery
-    const optedOutOfEmail =
-      optOutOfAllSettings.includes('email') &&
-      subscriptionType !== 'your_contract_closed'
-    const optedOutOfBrowser =
-      optOutOfAllSettings.includes('browser') &&
-      subscriptionType !== 'your_contract_closed'
+  const unsubscribeEndpoint = getFunctionUrl('unsubscribe')
  return {
-      sendToEmail: destinations.includes('email') && !optedOutOfEmail,
-      sendToBrowser: destinations.includes('browser') && !optedOutOfBrowser,
+    sendToEmail: destinations.includes('email'),
+    sendToBrowser: destinations.includes('browser'),
    unsubscribeUrl: `${unsubscribeEndpoint}?id=${privateUser.id}&type=${subscriptionType}`,
    urlToManageThisNotification: `${DOMAIN}/notifications?tab=settings&section=${subscriptionType}`,
  }
-  } catch (e) {
-    // Fail safely
-    console.log(
-      `couldn't get notification destinations for type ${reason} for user ${privateUser.id}`
-    )
-    return {
-      sendToEmail: false,
-      sendToBrowser: false,
-      unsubscribeUrl: '',
-      urlToManageThisNotification: '',
-    }
-  }
 }
--- a/common/user.ts
+++ b/common/user.ts
@ -1,6 +1,5 @@
 import { notification_preferences } from './user-notification-preferences'
-import { ENV_CONFIG } from './envs/constants'
-import { MarketCreatorBadge, ProvenCorrectBadge, StreakerBadge } from './badge'
+import { ENV_CONFIG } from 'common/envs/constants'

 export type User = {
  id: string
@ -12,6 +11,7 @@ export type User = {

  // For their user page
  bio?: string
+  bannerUrl?: string
  website?: string
  twitterHandle?: string
  discordHandle?: string
@ -33,8 +33,6 @@ export type User = {
    allTime: number
  }

-  fractionResolvedCorrectly: number
-
  nextLoanCached: number
  followerCountCached: number

@ -51,18 +49,6 @@ export type User = {
  hasSeenContractFollowModal?: boolean
  freeMarketsCreated?: number
  isBannedFromPosting?: boolean
-
-  achievements: {
-    provenCorrect?: {
-      badges: ProvenCorrectBadge[]
-    }
-    marketCreator?: {
-      badges: MarketCreatorBadge[]
-    }
-    streaker?: {
-      badges: StreakerBadge[]
-    }
-  }
 }

 export type PrivateUser = {
@ -93,8 +79,7 @@ export type PortfolioMetrics = {
  userId: string
 }

-export const MANIFOLD_USER_USERNAME = 'ManifoldMarkets'
-export const MANIFOLD_USER_NAME = 'ManifoldMarkets'
+export const MANIFOLD_USERNAME = 'ManifoldMarkets'
 export const MANIFOLD_AVATAR_URL = 'https://manifold.markets/logo-bg-white.png'

 // TODO: remove. Hardcoding the strings would be better.
--- a/common/util/color.ts
+++ b/common/util/color.ts
@ -1,24 +0,0 @@
-export const interpolateColor = (color1: string, color2: string, p: number) => {
-  const rgb1 = parseInt(color1.replace('#', ''), 16)
-  const rgb2 = parseInt(color2.replace('#', ''), 16)
-
-  const [r1, g1, b1] = toArray(rgb1)
-  const [r2, g2, b2] = toArray(rgb2)
-
-  const q = 1 - p
-  const rr = Math.round(r1 * q + r2 * p)
-  const rg = Math.round(g1 * q + g2 * p)
-  const rb = Math.round(b1 * q + b2 * p)
-
-  const hexString = Number((rr << 16) + (rg << 8) + rb).toString(16)
-  const hex = `#${'0'.repeat(6 - hexString.length)}${hexString}`
-  return hex
-}
-
-function toArray(rgb: number) {
-  const r = rgb >> 16
-  const g = (rgb >> 8) % 256
-  const b = rgb % 256
-
-  return [r, g, b]
-}
--- a/common/util/format.ts
+++ b/common/util/format.ts
@ -8,14 +8,7 @@ const formatter = new Intl.NumberFormat('en-US', {
 })

 export function formatMoney(amount: number) {
-  const newAmount =
-    // handle -0 case
-    Math.round(amount) === 0
-      ? 0
-      : // Handle 499.9999999999999 case
-        (amount > 0 ? Math.floor : Math.ceil)(
-          amount + 0.00000000001 * Math.sign(amount)
-        )
+  const newAmount = Math.round(amount) === 0 ? 0 : Math.floor(amount) // handle -0 case
  return ENV_CONFIG.moneyMoniker + formatter.format(newAmount).replace('$', '')
 }

@ -60,16 +53,6 @@ export function formatLargeNumber(num: number, sigfigs = 2): string {
  return `${numStr}${suffix[i] ?? ''}`
 }

-export function shortFormatNumber(num: number): string {
-  if (num < 1000) return showPrecision(num, 3)
-
-  const suffix = ['', 'K', 'M', 'B', 'T', 'Q']
-  const i = Math.floor(Math.log10(num) / 3)
-
-  const numStr = showPrecision(num / Math.pow(10, 3 * i), 2)
-  return `${numStr}${suffix[i] ?? ''}`
-}
-
 export function toCamelCase(words: string) {
  const camelCase = words
    .split(' ')
--- a/common/util/parse.ts
+++ b/common/util/parse.ts
@ -1,5 +1,5 @@
-import { generateText, JSONContent, Node } from '@tiptap/core'
-import { generateJSON } from '@tiptap/html'
+import { MAX_TAG_LENGTH } from '../contract'
+import { generateText, JSONContent } from '@tiptap/core'
 // Tiptap starter extensions
 import { Blockquote } from '@tiptap/extension-blockquote'
 import { Bold } from '@tiptap/extension-bold'
@ -25,7 +25,6 @@ import Iframe from './tiptap-iframe'
 import TiptapTweet from './tiptap-tweet-type'
 import { find } from 'linkifyjs'
 import { uniq } from 'lodash'
-import { TiptapSpoiler } from './tiptap-spoiler'

 /** get first url in text. like "notion.so " -> "http://notion.so"; "notion" -> null */
 export function getUrl(text: string) {
@ -33,6 +32,34 @@ export function getUrl(text: string) {
  return results.length ? results[0].href : null
 }

+export function parseTags(text: string) {
+  const regex = /(?:^|\s)(?:[#][a-z0-9_]+)/gi
+  const matches = (text.match(regex) || []).map((match) =>
+    match.trim().substring(1).substring(0, MAX_TAG_LENGTH)
+  )
+  const tagSet = new Set()
+  const uniqueTags: string[] = []
+  // Keep casing of last tag.
+  matches.reverse()
+  for (const tag of matches) {
+    const lowercase = tag.toLowerCase()
+    if (!tagSet.has(lowercase)) {
+      tagSet.add(lowercase)
+      uniqueTags.push(tag)
+    }
+  }
+  uniqueTags.reverse()
+  return uniqueTags
+}
+
+export function parseWordsAsTags(text: string) {
+  const taggedText = text
+    .split(/\s+/)
+    .map((tag) => (tag.startsWith('#') ? tag : `#${tag}`))
+    .join(' ')
+  return parseTags(taggedText)
+}
+
 // TODO: fuzzy matching
 export const wordIn = (word: string, corpus: string) =>
  corpus.toLocaleLowerCase().includes(word.toLocaleLowerCase())
@ -52,28 +79,8 @@ export function parseMentions(data: JSONContent): string[] {
  return uniq(mentions)
 }

-// TODO: this is a hack to get around the fact that tiptap doesn't have a
-// way to add a node view without bundling in tsx
-function skippableComponent(name: string): Node<any, any> {
-  return Node.create({
-    name,
-
-    group: 'block',
-
-    content: 'inline*',
-
-    parseHTML() {
-      return [
-        {
-          tag: 'grid-cards-component',
-        },
-      ]
-    },
-  })
-}
-
-const stringParseExts = [
-  // StarterKit extensions
+// can't just do [StarterKit, Image...] because it doesn't work with cjs imports
+export const exhibitExts = [
  Blockquote,
  Bold,
  BulletList,
@ -90,26 +97,14 @@ const stringParseExts = [
  Paragraph,
  Strike,
  Text,
-  // other extensions
+
+  Image,
  Link,
-  Image.extend({ renderText: () => '[image]' }),
-  Mention, // user @mention
-  Mention.extend({ name: 'contract-mention' }), // market %mention
-  Iframe.extend({
-    renderText: ({ node }) =>
-      '[embed]' + node.attrs.src ? `(${node.attrs.src})` : '',
-  }),
-  skippableComponent('gridCardsComponent'),
-  skippableComponent('staticReactEmbedComponent'),
-  TiptapTweet.extend({ renderText: () => '[tweet]' }),
-  TiptapSpoiler.extend({ renderHTML: () => ['span', '[spoiler]', 0] }),
+  Mention,
+  Iframe,
+  TiptapTweet,
 ]

 export function richTextToString(text?: JSONContent) {
-  if (!text) return ''
-  return generateText(text, stringParseExts)
-}
-
-export function htmlToRichText(html: string) {
-  return generateJSON(html, stringParseExts)
+  return !text ? '' : generateText(text, exhibitExts)
 }
--- a/common/util/tiptap-spoiler.ts
+++ b/common/util/tiptap-spoiler.ts
@ -1,116 +0,0 @@
-// adapted from @n8body/tiptap-spoiler
-
-import {
-  Mark,
-  markInputRule,
-  markPasteRule,
-  mergeAttributes,
-} from '@tiptap/core'
-import type { ElementType } from 'react'
-
-declare module '@tiptap/core' {
-  interface Commands<ReturnType> {
-    spoilerEditor: {
-      setSpoiler: () => ReturnType
-      toggleSpoiler: () => ReturnType
-      unsetSpoiler: () => ReturnType
-    }
-  }
-}
-
-export type SpoilerOptions = {
-  HTMLAttributes: Record<string, any>
-  spoilerOpenClass: string
-  spoilerCloseClass?: string
-  inputRegex: RegExp
-  pasteRegex: RegExp
-  as: ElementType
-}
-
-const spoilerInputRegex = /(?:^|\s)((?:\|\|)((?:[^||]+))(?:\|\|))$/
-const spoilerPasteRegex = /(?:^|\s)((?:\|\|)((?:[^||]+))(?:\|\|))/g
-
-export const TiptapSpoiler = Mark.create<SpoilerOptions>({
-  name: 'spoiler',
-
-  inline: true,
-  group: 'inline',
-  inclusive: false,
-  exitable: true,
-  content: 'inline*',
-
-  priority: 1001, // higher priority than other formatting so they go inside
-
-  addOptions() {
-    return {
-      HTMLAttributes: { 'aria-label': 'spoiler' },
-      spoilerOpenClass: '',
-      spoilerCloseClass: undefined,
-      inputRegex: spoilerInputRegex,
-      pasteRegex: spoilerPasteRegex,
-      as: 'span',
-      editing: false,
-    }
-  },
-
-  addCommands() {
-    return {
-      setSpoiler:
-        () =>
-        ({ commands }) =>
-          commands.setMark(this.name),
-      toggleSpoiler:
-        () =>
-        ({ commands }) =>
-          commands.toggleMark(this.name),
-      unsetSpoiler:
-        () =>
-        ({ commands }) =>
-          commands.unsetMark(this.name),
-    }
-  },
-
-  addInputRules() {
-    return [
-      markInputRule({
-        find: this.options.inputRegex,
-        type: this.type,
-      }),
-    ]
-  },
-
-  addPasteRules() {
-    return [
-      markPasteRule({
-        find: this.options.pasteRegex,
-        type: this.type,
-      }),
-    ]
-  },
-
-  parseHTML() {
-    return [
-      {
-        tag: 'span',
-        getAttrs: (node) =>
-          (node as HTMLElement).ariaLabel?.toLowerCase() === 'spoiler' && null,
-      },
-    ]
-  },
-
-  renderHTML({ HTMLAttributes }) {
-    const elem = document.createElement(this.options.as as string)
-
-    Object.entries(
-      mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
-        class: this.options.spoilerCloseClass ?? this.options.spoilerOpenClass,
-      })
-    ).forEach(([attr, val]) => elem.setAttribute(attr, val))
-
-    elem.addEventListener('click', () => {
-      elem.setAttribute('class', this.options.spoilerOpenClass)
-    })
-
-    return elem
-  },
-})
--- a/docs/docs/api.md
+++ b/docs/docs/api.md
@ -55,7 +55,6 @@ Returns the authenticated user.
 Gets all groups, in no particular order.

 Parameters:
-
 - `availableToUserId`: Optional. if specified, only groups that the user can
  join and groups they've already joined will be returned.

@ -82,6 +81,7 @@ Gets a group's markets by its unique ID.
 Requires no authorization.  
 Note: group is singular in the URL.

+
 ### `GET /v0/markets`

 Lists all markets, ordered by creation date descending.
@ -158,16 +158,13 @@ Requires no authorization.
    //   i.e. https://manifold.markets/Austin/test-market is the same as https://manifold.markets/foo/test-market
    url: string

-    outcomeType: string // BINARY, FREE_RESPONSE, MULTIPLE_CHOICE, NUMERIC, or PSEUDO_NUMERIC
+    outcomeType: string // BINARY, FREE_RESPONSE, or NUMERIC
    mechanism: string // dpm-2 or cpmm-1

    probability: number
    pool: { outcome: number } // For CPMM markets, the number of shares in the liquidity pool. For DPM markets, the amount of mana invested in each answer.
    p?: number // CPMM markets only, probability constant in y^p * n^(1-p) = k
    totalLiquidity?: number // CPMM markets only, the amount of mana deposited into the liquidity pool
-    min?: number // PSEUDO_NUMERIC markets only, the minimum resolvable value
-    max?: number // PSEUDO_NUMERIC markets only, the maximum resolvable value
-    isLogScale?: bool // PSEUDO_NUMERIC markets only, if true `number = (max - min + 1)^probability + minstart - 1`, otherwise `number = min + (max - min) * probability`

    volume: number
    volume7Days: number
@ -411,7 +408,7 @@ Requires no authorization.
  type FullMarket = LiteMarket & {
    bets: Bet[]
    comments: Comment[]
-    answers?: Answer[] // dpm-2 markets only
+    answers?: Answer[]
    description: JSONContent // Rich text content. See https://tiptap.dev/guide/output#option-1-json
    textDescription: string // string description without formatting, images, or embeds
  }
@ -557,7 +554,7 @@ Creates a new market on behalf of the authorized user.

 Parameters:

- `outcomeType`: Required. One of `BINARY`, `FREE_RESPONSE`, `MULTIPLE_CHOICE`, or `PSEUDO_NUMERIC`.
+- `outcomeType`: Required. One of `BINARY`, `FREE_RESPONSE`, or `NUMERIC`.
 - `question`: Required. The headline question for the market.
 - `description`: Required. A long description describing the rules for the market.
  - Note: string descriptions do **not** turn into links, mentions, formatted text. Instead, rich text descriptions must be in [TipTap json](https://tiptap.dev/guide/output#option-1-json).
@ -572,12 +569,6 @@ For numeric markets, you must also provide:

 - `min`: The minimum value that the market may resolve to.
 - `max`: The maximum value that the market may resolve to.
- `isLogScale`: If true, your numeric market will increase exponentially from min to max.
- `initialValue`: An initial value for the market, between min and max, exclusive.
-
-For multiple choice markets, you must also provide:
-
- `answers`: An array of strings, each of which will be a valid answer for the market.

 Example request:

@ -591,18 +582,13 @@ $ curl https://manifold.markets/api/v0/market -X POST -H 'Content-Type: applicat
                 "initialProb":25}'
 ```

-### `POST /v0/market/[marketId]/add-liquidity`
-
-Adds a specified amount of liquidity into the market.
-
- `amount`: Required. The amount of liquidity to add, in M$.

 ### `POST /v0/market/[marketId]/close`

 Closes a market on behalf of the authorized user.
-
 - `closeTime`: Optional. Milliseconds since the epoch to close the market at. If not provided, the market will be closed immediately. Cannot provide close time in past.

+
 ### `POST /v0/market/[marketId]/resolve`

 Resolves a market on behalf of the authorized user.
@ -614,18 +600,15 @@ For binary markets:
 - `outcome`: Required. One of `YES`, `NO`, `MKT`, or `CANCEL`.
 - `probabilityInt`: Optional. The probability to use for `MKT` resolution.

-For free response or multiple choice markets:
+For free response markets:

 - `outcome`: Required. One of `MKT`, `CANCEL`, or a `number` indicating the answer index.
- `resolutions`: An array of `{ answer, pct }` objects to use as the weights for resolving in favor of multiple free response options. Can only be set with `MKT` outcome. Note that the total weights must add to 100.
+- `resolutions`: An array of `{ answer, pct }` objects to use as the weights for resolving in favor of multiple free response options. Can only be set with `MKT` outcome.

 For numeric markets:

 - `outcome`: Required. One of `CANCEL`, or a `number` indicating the selected numeric bucket ID.
 - `value`: The value that the market may resolves to.
- `probabilityInt`: Required if `value` is present. Should be equal to
-  - If log scale: `log10(value - min + 1) / log10(max - min + 1)`
-  - Otherwise: `(value - min) / (max - min)`

 Example request:

@ -680,17 +663,6 @@ $ curl https://manifold.markets/api/v0/market/{marketId}/sell -X POST \
    --data-raw '{"outcome": "YES", "shares": 10}'
 ```

-### `POST /v0/comment`
-
-Creates a comment in the specified market. Only supports top-level comments for now.
-
-Parameters:
-
- `contractId`: Required. The ID of the market to comment on.
- `content`: The comment to post, formatted as [TipTap json](https://tiptap.dev/guide/output#option-1-json), OR
- `html`: The comment to post, formatted as an HTML string, OR
- `markdown`: The comment to post, formatted as a markdown string.
-
 ### `GET /v0/bets`

 Gets a list of bets, ordered by creation date descending.
@ -780,7 +752,6 @@ Requires no authorization.

 ## Changelog

- 2022-09-24: Expand market POST docs to include new market types (`PSEUDO_NUMERIC`, `MULTIPLE_CHOICE`)
 - 2022-07-15: Add user by username and user by ID APIs
 - 2022-06-08: Add paging to markets endpoint
 - 2022-06-05: Add new authorized write endpoints
--- a/docs/docs/bounties.md
+++ b/docs/docs/bounties.md
@ -15,22 +15,6 @@ Our community is the beating heart of Manifold; your individual contributions ar

 ## Awarded bounties

-💥 *Awarded on 2022-10-07*
-
-**[Pepe](https://manifold.markets/Pepe): M$10,000**
-**[Jack](https://manifold.markets/jack): M$2,000**
-**[Martin](https://manifold.markets/MartinRandall): M$2,000**
-**[Yev](https://manifold.markets/Yev): M$2,000**
-**[Michael](https://manifold.markets/MichaelWheatley): M$2,000**
-
- For discovering an infinite mana exploit using limit orders, and informing the Manifold team of it privately.
-
-**[Matt](https://manifold.markets/MattP): M$5,000**
-**[Adrian](https://manifold.markets/ahalekelly): M$5,000**
-**[Yev](https://manifold.markets/Yev): M$5,000**
-
- For discovering an AMM liquidity exploit and informing the Manifold team of it privately.
-
 🎈 *Awarded on 2022-06-14*

 **[Wasabipesto](https://manifold.markets/wasabipesto): M$20,000**
--- a/firestore.rules
+++ b/firestore.rules
@ -23,17 +23,11 @@ service cloud.firestore {
      allow read;
    }

-    match /globalConfig/globalConfig {
-      allow read;
-      allow update: if isAdmin()
-      allow create: if isAdmin()
-    }
-
    match /users/{userId} {
      allow read;
      allow update: if userId == request.auth.uid
                       && request.resource.data.diff(resource.data).affectedKeys()
-                                                                    .hasOnly(['bio', 'website', 'twitterHandle', 'discordHandle', 'followedCategories', 'lastPingTime','shouldShowWelcome', 'hasSeenContractFollowModal', 'homeSections']);
+                                                                    .hasOnly(['bio', 'bannerUrl', 'website', 'twitterHandle', 'discordHandle', 'followedCategories', 'lastPingTime','shouldShowWelcome', 'hasSeenContractFollowModal', 'homeSections']);
      // User referral rules
      allow update: if userId == request.auth.uid
                         && request.resource.data.diff(resource.data).affectedKeys()
@ -50,10 +44,6 @@ service cloud.firestore {
      allow read;
    }

-    match /{somePath=**}/contract-metrics/{contractId} {
-      allow read;
-    }
-
    match /{somePath=**}/challenges/{challengeId}{
      allow read;
    }
@ -110,9 +100,9 @@ service cloud.firestore {
    match /contracts/{contractId} {
      allow read;
      allow update: if request.resource.data.diff(resource.data).affectedKeys()
-                                                                 .hasOnly(['tags', 'lowercaseTags', 'groupSlugs', 'groupLinks', 'flaggedByUsernames']);
+                                                                 .hasOnly(['tags', 'lowercaseTags', 'groupSlugs', 'groupLinks']);
      allow update: if request.resource.data.diff(resource.data).affectedKeys()
-                                                                 .hasOnly(['description', 'closeTime', 'question', 'visibility', 'unlistedById'])
+                                                                 .hasOnly(['description', 'closeTime', 'question'])
                       && resource.data.creatorId == request.auth.uid;
      allow update: if isAdmin();
          match /comments/{commentId} {
@ -186,7 +176,7 @@ service cloud.firestore {
      allow update: if (request.auth.uid == resource.data.creatorId || isAdmin())
                        && request.resource.data.diff(resource.data)
                        .affectedKeys()
-                        .hasOnly(['name', 'about', 'anyoneCanJoin', 'aboutPostId', 'pinnedItems' ]);
+                        .hasOnly(['name', 'about', 'anyoneCanJoin', 'aboutPostId' ]);
      allow delete: if request.auth.uid == resource.data.creatorId;

      match /groupContracts/{contractId} {
--- a/functions/.env.prod
+++ b/functions/.env.prod
--- a/functions/.env.dev
+++ b/functions/.env.dev
@ -1,3 +0,0 @@
-# This sets which EnvConfig is deployed to Firebase Cloud Functions
-
-NEXT_PUBLIC_FIREBASE_ENV=DEV
--- a/functions/.eslintrc.js
+++ b/functions/.eslintrc.js
@ -26,7 +26,7 @@ module.exports = {
            caughtErrorsIgnorePattern: '^_',
          },
        ],
-        'unused-imports/no-unused-imports': 'warn',
+        'unused-imports/no-unused-imports': 'error',
      },
    },
  ],
--- a/functions/README.md
+++ b/functions/README.md
@ -20,7 +20,7 @@ Adapted from https://firebase.google.com/docs/functions/get-started
 3. `$ firebase login` to authenticate the CLI tools to Firebase
 4. `$ firebase use dev` to choose the dev project

-#### (Installing) For local development
+### For local development

 0. [Install](https://cloud.google.com/sdk/docs/install) gcloud CLI
 1. If you don't have java (or see the error `Error: Process java -version has exited with code 1. Please make sure Java is installed and on your system PATH.`):
@ -35,10 +35,10 @@ Adapted from https://firebase.google.com/docs/functions/get-started

 ## Developing locally

-0. `$ ./dev.sh localdb` to start the local emulator and front end
-1. If you change db trigger code, you have to start (doesn't have to complete) the deploy of it to dev to cause a hard emulator code refresh `$ firebase deploy --only functions:dbTriggerNameHere`
-   - There's surely a better way to cause/react to a db trigger update but just adding this here for now as it works
-2. If you want to test a scheduled function replace your function in `test-scheduled-function.ts` and send a GET to `http://localhost:8088/testscheduledfunction` (Best user experience is via [Postman](https://www.postman.com/downloads/)!)
+0. `$ firebase use dev` if you haven't already
+1. `$ yarn serve` to spin up the emulators 0. The Emulator UI is at http://localhost:4000; the functions are hosted on :5001.
+   Note: You have to kill and restart emulators when you change code; no hot reload =(
+2. `$ yarn dev:emulate` in `/web` to connect to emulators with the frontend 0. Note: emulated database is cleared after every shutdown

 ## Firestore Commands

--- a/functions/package.json
+++ b/functions/package.json
@ -5,7 +5,7 @@
    "firestore": "dev-mantic-markets.appspot.com"
  },
  "scripts": {
-    "build": "yarn compile && rm -rf dist && mkdir -p dist/functions && cp -R ../common/lib dist/common && cp -R lib/src dist/functions/src && cp ../yarn.lock dist && cp package.json dist && cp .env.prod dist && cp .env.dev dist",
+    "build": "yarn compile && rm -rf dist && mkdir -p dist/functions && cp -R ../common/lib dist/common && cp -R lib/src dist/functions/src && cp ../yarn.lock dist && cp package.json dist && cp .env dist",
    "compile": "tsc -b",
    "watch": "tsc -w",
    "shell": "yarn build && firebase functions:shell",
@ -15,9 +15,9 @@
    "dev": "nodemon src/serve.ts",
    "localDbScript": "firebase emulators:start --only functions,firestore,pubsub --import=./firestore_export",
    "serve": "firebase use dev && yarn build && firebase emulators:start --only functions,firestore,pubsub --import=./firestore_export",
-    "db:update-local-from-remote": "yarn db:backup-remote && gsutil -m rsync -r gs://$npm_package_config_firestore/firestore_export ./firestore_export",
+    "db:update-local-from-remote": "yarn db:backup-remote && gsutil rsync -r gs://$npm_package_config_firestore/firestore_export ./firestore_export",
    "db:backup-local": "firebase emulators:export --force ./firestore_export",
-    "db:rename-remote-backup-folder": "gsutil -m mv gs://$npm_package_config_firestore/firestore_export gs://$npm_package_config_firestore/firestore_export_$(date +%d-%m-%Y-%H-%M)",
+    "db:rename-remote-backup-folder": "gsutil mv gs://$npm_package_config_firestore/firestore_export gs://$npm_package_config_firestore/firestore_export_$(date +%d-%m-%Y-%H-%M)",
    "db:backup-remote": "yarn db:rename-remote-backup-folder && gcloud firestore export gs://$npm_package_config_firestore/firestore_export/",
    "verify": "(cd .. && yarn verify)",
    "verify:dir": "npx eslint . --max-warnings 0; tsc -b -v --pretty"
@ -26,13 +26,11 @@
  "dependencies": {
    "@amplitude/node": "1.10.0",
    "@google-cloud/functions-framework": "3.1.2",
-    "@tiptap/core": "2.0.0-beta.199",
-    "@tiptap/extension-image": "2.0.0-beta.199",
-    "@tiptap/extension-link": "2.0.0-beta.199",
-    "@tiptap/extension-mention": "2.0.0-beta.199",
-    "@tiptap/html": "2.0.0-beta.199",
-    "@tiptap/starter-kit": "2.0.0-beta.199",
-    "@tiptap/suggestion": "2.0.0-beta.199",
+    "@tiptap/core": "2.0.0-beta.182",
+    "@tiptap/extension-image": "2.0.0-beta.30",
+    "@tiptap/extension-link": "2.0.0-beta.43",
+    "@tiptap/extension-mention": "2.0.0-beta.102",
+    "@tiptap/starter-kit": "2.0.0-beta.191",
    "cors": "2.8.5",
    "dayjs": "1.11.4",
    "express": "4.18.1",
@ -40,7 +38,6 @@
    "firebase-functions": "3.21.2",
    "lodash": "4.17.21",
    "mailgun-js": "0.22.0",
-    "marked": "4.1.1",
    "module-alias": "2.2.2",
    "node-fetch": "2",
    "stripe": "8.194.0",
@ -48,7 +45,6 @@
  },
  "devDependencies": {
    "@types/mailgun-js": "0.22.12",
-    "@types/marked": "4.0.7",
    "@types/module-alias": "2.0.1",
    "@types/node-fetch": "2.6.2",
    "firebase-functions-test": "0.3.3",
--- a/functions/src/add-liquidity.ts
+++ b/functions/src/add-liquidity.ts
@ -3,18 +3,24 @@ import { z } from 'zod'

 import { Contract, CPMMContract } from '../../common/contract'
 import { User } from '../../common/user'
+import { removeUndefinedProps } from '../../common/util/object'
 import { getNewLiquidityProvision } from '../../common/add-liquidity'
 import { APIError, newEndpoint, validate } from './api'
+import {
+  DEV_HOUSE_LIQUIDITY_PROVIDER_ID,
+  HOUSE_LIQUIDITY_PROVIDER_ID,
+} from '../../common/antes'
+import { isProd } from './utils'

 const bodySchema = z.object({
  contractId: z.string(),
  amount: z.number().gt(0),
 })

-export const addsubsidy = newEndpoint({}, async (req, auth) => {
+export const addliquidity = newEndpoint({}, async (req, auth) => {
  const { amount, contractId } = validate(bodySchema, req.body)

-  if (!isFinite(amount) || amount < 1) throw new APIError(400, 'Invalid amount')
+  if (!isFinite(amount)) throw new APIError(400, 'Invalid amount')

  // run as transaction to prevent race conditions
  return await firestore.runTransaction(async (transaction) => {
@ -44,7 +50,7 @@ export const addsubsidy = newEndpoint({}, async (req, auth) => {
      .collection(`contracts/${contractId}/liquidity`)
      .doc()

-    const { newLiquidityProvision, newTotalLiquidity, newSubsidyPool } =
+    const { newLiquidityProvision, newPool, newP, newTotalLiquidity } =
      getNewLiquidityProvision(
        user.id,
        amount,
@ -52,10 +58,21 @@ export const addsubsidy = newEndpoint({}, async (req, auth) => {
        newLiquidityProvisionDoc.id
      )

-    transaction.update(contractDoc, {
-      subsidyPool: newSubsidyPool,
+    if (newP !== undefined && !isFinite(newP)) {
+      return {
+        status: 'error',
+        message: 'Liquidity injection rejected due to overflow error.',
+      }
+    }
+
+    transaction.update(
+      contractDoc,
+      removeUndefinedProps({
+        pool: newPool,
+        p: newP,
        totalLiquidity: newTotalLiquidity,
-    } as Partial<CPMMContract>)
+      })
+    )

    const newBalance = user.balance - amount
    const newTotalDeposits = user.totalDeposits - amount
@ -76,3 +93,41 @@ export const addsubsidy = newEndpoint({}, async (req, auth) => {
 })

 const firestore = admin.firestore()
+
+export const addHouseLiquidity = (contract: CPMMContract, amount: number) => {
+  return firestore.runTransaction(async (transaction) => {
+    const newLiquidityProvisionDoc = firestore
+      .collection(`contracts/${contract.id}/liquidity`)
+      .doc()
+
+    const providerId = isProd()
+      ? HOUSE_LIQUIDITY_PROVIDER_ID
+      : DEV_HOUSE_LIQUIDITY_PROVIDER_ID
+
+    const { newLiquidityProvision, newPool, newP, newTotalLiquidity } =
+      getNewLiquidityProvision(
+        providerId,
+        amount,
+        contract,
+        newLiquidityProvisionDoc.id
+      )
+
+    if (newP !== undefined && !isFinite(newP)) {
+      throw new APIError(
+        500,
+        'Liquidity injection rejected due to overflow error.'
+      )
+    }
+
+    transaction.update(
+      firestore.doc(`contracts/${contract.id}`),
+      removeUndefinedProps({
+        pool: newPool,
+        p: newP,
+        totalLiquidity: newTotalLiquidity,
+      })
+    )
+
+    transaction.create(newLiquidityProvisionDoc, newLiquidityProvision)
+  })
+}
--- a/functions/src/api.ts
+++ b/functions/src/api.ts
@ -14,7 +14,7 @@ import {
 export { APIError } from '../../common/api'

 type Output = Record<string, unknown>
-export type AuthedUser = {
+type AuthedUser = {
  uid: string
  creds: JwtCredentials | (KeyCredentials & { privateUser: PrivateUser })
 }
@ -146,24 +146,3 @@ export const newEndpoint = (endpointOpts: EndpointOptions, fn: Handler) => {
    },
  } as EndpointDefinition
 }
-
-export const newEndpointNoAuth = (
-  endpointOpts: EndpointOptions,
-  fn: (req: Request) => Promise<Output>
-) => {
-  const opts = Object.assign({}, DEFAULT_OPTS, endpointOpts)
-  return {
-    opts,
-    handler: async (req: Request, res: Response) => {
-      log(`${req.method} ${req.url} ${JSON.stringify(req.body)}`)
-      try {
-        if (opts.method !== req.method) {
-          throw new APIError(405, `This endpoint supports only ${opts.method}.`)
-        }
-        res.status(200).json(await fn(req))
-      } catch (e) {
-        writeResponseError(e, res)
-      }
-    },
-  } as EndpointDefinition
-}
--- a/functions/src/create-comment.ts
+++ b/functions/src/create-comment.ts
@ -1,105 +0,0 @@
-import * as admin from 'firebase-admin'
-
-import { getContract, getUser, log } from './utils'
-import { APIError, newEndpoint, validate } from './api'
-import { JSONContent } from '@tiptap/core'
-import { z } from 'zod'
-import { removeUndefinedProps } from '../../common/util/object'
-import { htmlToRichText } from '../../common/util/parse'
-import { marked } from 'marked'
-
-const contentSchema: z.ZodType<JSONContent> = z.lazy(() =>
-  z.intersection(
-    z.record(z.any()),
-    z.object({
-      type: z.string().optional(),
-      attrs: z.record(z.any()).optional(),
-      content: z.array(contentSchema).optional(),
-      marks: z
-        .array(
-          z.intersection(
-            z.record(z.any()),
-            z.object({
-              type: z.string(),
-              attrs: z.record(z.any()).optional(),
-            })
-          )
-        )
-        .optional(),
-      text: z.string().optional(),
-    })
-  )
-)
-
-const postSchema = z.object({
-  contractId: z.string(),
-  content: contentSchema.optional(),
-  html: z.string().optional(),
-  markdown: z.string().optional(),
-})
-
-const MAX_COMMENT_JSON_LENGTH = 20000
-
-// For now, only supports creating a new top-level comment on a contract.
-// Replies, posts, chats are not supported yet.
-export const createcomment = newEndpoint({}, async (req, auth) => {
-  const firestore = admin.firestore()
-  const { contractId, content, html, markdown } = validate(postSchema, req.body)
-
-  const creator = await getUser(auth.uid)
-  const contract = await getContract(contractId)
-
-  if (!creator) {
-    throw new APIError(400, 'No user exists with the authenticated user ID.')
-  }
-  if (!contract) {
-    throw new APIError(400, 'No contract exists with the given ID.')
-  }
-
-  let contentJson = null
-  if (content) {
-    contentJson = content
-  } else if (html) {
-    console.log('html', html)
-    contentJson = htmlToRichText(html)
-  } else if (markdown) {
-    const markedParse = marked.parse(markdown)
-    log('parsed', markedParse)
-    contentJson = htmlToRichText(markedParse)
-    log('json', contentJson)
-  }
-
-  if (!contentJson) {
-    throw new APIError(400, 'No comment content provided.')
-  }
-
-  if (JSON.stringify(contentJson).length > MAX_COMMENT_JSON_LENGTH) {
-    throw new APIError(
-      400,
-      `Comment is too long; should be less than ${MAX_COMMENT_JSON_LENGTH} as a JSON string.`
-    )
-  }
-
-  const ref = firestore.collection(`contracts/${contractId}/comments`).doc()
-
-  const comment = removeUndefinedProps({
-    id: ref.id,
-    content: contentJson,
-    createdTime: Date.now(),
-
-    userId: creator.id,
-    userName: creator.name,
-    userUsername: creator.username,
-    userAvatarUrl: creator.avatarUrl,
-
-    // OnContract fields
-    commentType: 'contract',
-    contractId: contractId,
-    contractSlug: contract.slug,
-    contractQuestion: contract.question,
-  })
-
-  await ref.set(comment)
-
-  return { status: 'success', comment }
-})
--- a/functions/src/create-group.ts
+++ b/functions/src/create-group.ts
@ -62,7 +62,6 @@ export const creategroup = newEndpoint({}, async (req, auth) => {
    totalContracts: 0,
    totalMembers: memberIds.length,
    postIds: [],
-    pinnedItems: [],
  }

  await groupRef.create(group)
--- a/functions/src/create-market.ts
+++ b/functions/src/create-market.ts
@ -16,7 +16,7 @@ import { slugify } from '../../common/util/slugify'
 import { randomString } from '../../common/util/random'

 import { chargeUser, getContract, isProd } from './utils'
-import { APIError, AuthedUser, newEndpoint, validate, zTimestamp } from './api'
+import { APIError, newEndpoint, validate, zTimestamp } from './api'

 import { FIXED_ANTE, FREE_MARKETS_PER_USER_MAX } from '../../common/economy'
 import {
@ -92,11 +92,7 @@ const multipleChoiceSchema = z.object({
  answers: z.string().trim().min(1).array().min(2),
 })

-export const createmarket = newEndpoint({}, (req, auth) => {
-  return createMarketHelper(req.body, auth)
-})
-
-export async function createMarketHelper(body: any, auth: AuthedUser) {
+export const createmarket = newEndpoint({}, async (req, auth) => {
  const {
    question,
    description,
@ -105,13 +101,16 @@ export async function createMarketHelper(body: any, auth: AuthedUser) {
    outcomeType,
    groupId,
    visibility = 'public',
-  } = validate(bodySchema, body)
+  } = validate(bodySchema, req.body)

  let min, max, initialProb, isLogScale, answers

  if (outcomeType === 'PSEUDO_NUMERIC' || outcomeType === 'NUMERIC') {
    let initialValue
-    ;({ min, max, initialValue, isLogScale } = validate(numericSchema, body))
+    ;({ min, max, initialValue, isLogScale } = validate(
+      numericSchema,
+      req.body
+    ))
    if (max - min <= 0.01 || initialValue <= min || initialValue >= max)
      throw new APIError(400, 'Invalid range.')

@ -127,11 +126,11 @@ export async function createMarketHelper(body: any, auth: AuthedUser) {
  }

  if (outcomeType === 'BINARY') {
-    ;({ initialProb } = validate(binarySchema, body))
+    ;({ initialProb } = validate(binarySchema, req.body))
  }

  if (outcomeType === 'MULTIPLE_CHOICE') {
-    ;({ answers } = validate(multipleChoiceSchema, body))
+    ;({ answers } = validate(multipleChoiceSchema, req.body))
  }

  const userDoc = await firestore.collection('users').doc(auth.uid).get()
@ -187,17 +186,17 @@ export async function createMarketHelper(body: any, auth: AuthedUser) {

  // convert string descriptions into JSONContent
  const newDescription =
-    !description || typeof description === 'string'
+    typeof description === 'string'
      ? {
          type: 'doc',
          content: [
            {
              type: 'paragraph',
-              content: [{ type: 'text', text: description || ' ' }],
+              content: [{ type: 'text', text: description }],
            },
          ],
        }
-      : description
+      : description ?? {}

  const contract = getNewContract(
    contractRef.id,
@ -324,7 +323,7 @@ export async function createMarketHelper(body: any, auth: AuthedUser) {
  }

  return contract
-}
+})

 const getSlug = async (question: string) => {
  const proposedSlug = slugify(question)
--- a/functions/src/create-notification.ts
+++ b/functions/src/create-notification.ts
@ -6,13 +6,7 @@ import {
  Notification,
  notification_reason_types,
 } from '../../common/notification'
-import {
-  MANIFOLD_AVATAR_URL,
-  MANIFOLD_USER_NAME,
-  MANIFOLD_USER_USERNAME,
-  PrivateUser,
-  User,
-} from '../../common/user'
+import { User } from '../../common/user'
 import { Contract } from '../../common/contract'
 import { getPrivateUser, getValues } from './utils'
 import { Comment } from '../../common/comment'
@ -36,26 +30,27 @@ import {
 import { filterDefined } from '../../common/util/array'
 import { getNotificationDestinationsForUser } from '../../common/user-notification-preferences'
 import { ContractFollow } from '../../common/follow'
-import { Badge } from 'common/badge'
 const firestore = admin.firestore()

 type recipients_to_reason_texts = {
  [userId: string]: { reason: notification_reason_types }
 }

-export const createFollowOrMarketSubsidizedNotification = async (
+export const createNotification = async (
  sourceId: string,
-  sourceType: 'liquidity' | 'follow',
-  sourceUpdateType: 'created',
+  sourceType: 'contract' | 'liquidity' | 'follow',
+  sourceUpdateType: 'closed' | 'created',
  sourceUser: User,
  idempotencyKey: string,
  sourceText: string,
  miscData?: {
    contract?: Contract
    recipients?: string[]
+    slug?: string
+    title?: string
  }
 ) => {
-  const { contract: sourceContract, recipients } = miscData ?? {}
+  const { contract: sourceContract, recipients, slug, title } = miscData ?? {}

  const shouldReceiveNotification = (
    userId: string,
@ -99,15 +94,23 @@ export const createFollowOrMarketSubsidizedNotification = async (
          sourceContractCreatorUsername: sourceContract?.creatorUsername,
          sourceContractTitle: sourceContract?.question,
          sourceContractSlug: sourceContract?.slug,
-          sourceSlug: sourceContract?.slug,
-          sourceTitle: sourceContract?.question,
+          sourceSlug: slug ? slug : sourceContract?.slug,
+          sourceTitle: title ? title : sourceContract?.question,
        }
        await notificationRef.set(removeUndefinedProps(notification))
      }

      if (!sendToEmail) continue

-      if (reason === 'subsidized_your_market') {
+      if (reason === 'your_contract_closed' && privateUser && sourceContract) {
+        // TODO: include number and names of bettors waiting for creator to resolve their market
+        await sendMarketCloseEmail(
+          reason,
+          sourceUser,
+          privateUser,
+          sourceContract
+        )
+      } else if (reason === 'subsidized_your_market') {
        // TODO: send email to creator of market that was subsidized
      } else if (reason === 'on_new_follow') {
        // TODO: send email to user who was followed
@ -124,7 +127,20 @@ export const createFollowOrMarketSubsidizedNotification = async (
        reason: 'on_new_follow',
      }
    return await sendNotificationsIfSettingsPermit(userToReasonTexts)
-  } else if (sourceType === 'liquidity' && sourceContract) {
+  } else if (
+    sourceType === 'contract' &&
+    sourceUpdateType === 'closed' &&
+    sourceContract
+  ) {
+    userToReasonTexts[sourceContract.creatorId] = {
+      reason: 'your_contract_closed',
+    }
+    return await sendNotificationsIfSettingsPermit(userToReasonTexts)
+  } else if (
+    sourceType === 'liquidity' &&
+    sourceUpdateType === 'created' &&
+    sourceContract
+  ) {
    if (shouldReceiveNotification(sourceContract.creatorId, userToReasonTexts))
      userToReasonTexts[sourceContract.creatorId] = {
        reason: 'subsidized_your_market',
@ -197,7 +213,6 @@ export const createCommentOrAnswerOrUpdatedContractNotification = async (
    return await notificationRef.set(removeUndefinedProps(notification))
  }

-  const needNotFollowContractReasons = ['tagged_user']
  const stillFollowingContract = (userId: string) => {
    return contractFollowersIds.includes(userId)
  }
@ -206,12 +221,7 @@ export const createCommentOrAnswerOrUpdatedContractNotification = async (
    userId: string,
    reason: notification_reason_types
  ) => {
-    if (
-      (!stillFollowingContract(userId) &&
-        !needNotFollowContractReasons.includes(reason)) ||
-      sourceUser.id == userId
-    )
-      return
+    if (!stillFollowingContract(userId) || sourceUser.id == userId) return
    const privateUser = await getPrivateUser(userId)
    if (!privateUser) return
    const { sendToBrowser, sendToEmail } = getNotificationDestinationsForUser(
@ -1036,122 +1046,3 @@ export const createContractResolvedNotifications = async (
    )
  )
 }
-
-export const createBountyNotification = async (
-  fromUser: User,
-  toUserId: string,
-  amount: number,
-  idempotencyKey: string,
-  contract: Contract,
-  commentId?: string
-) => {
-  const privateUser = await getPrivateUser(toUserId)
-  if (!privateUser) return
-  const { sendToBrowser } = getNotificationDestinationsForUser(
-    privateUser,
-    'tip_received'
-  )
-  if (!sendToBrowser) return
-
-  const slug = commentId
-  const notificationRef = firestore
-    .collection(`/users/${toUserId}/notifications`)
-    .doc(idempotencyKey)
-  const notification: Notification = {
-    id: idempotencyKey,
-    userId: toUserId,
-    reason: 'tip_received',
-    createdTime: Date.now(),
-    isSeen: false,
-    sourceId: commentId ? commentId : contract.id,
-    sourceType: 'tip',
-    sourceUpdateType: 'created',
-    sourceUserName: fromUser.name,
-    sourceUserUsername: fromUser.username,
-    sourceUserAvatarUrl: fromUser.avatarUrl,
-    sourceText: amount.toString(),
-    sourceContractCreatorUsername: contract.creatorUsername,
-    sourceContractTitle: contract.question,
-    sourceContractSlug: contract.slug,
-    sourceSlug: slug,
-    sourceTitle: contract.question,
-  }
-  return await notificationRef.set(removeUndefinedProps(notification))
-}
-
-export const createBadgeAwardedNotification = async (
-  user: User,
-  badge: Badge
-) => {
-  const privateUser = await getPrivateUser(user.id)
-  if (!privateUser) return
-  const { sendToBrowser } = getNotificationDestinationsForUser(
-    privateUser,
-    'badges_awarded'
-  )
-  if (!sendToBrowser) return
-
-  const notificationRef = firestore
-    .collection(`/users/${user.id}/notifications`)
-    .doc()
-  const notification: Notification = {
-    id: notificationRef.id,
-    userId: user.id,
-    reason: 'badges_awarded',
-    createdTime: Date.now(),
-    isSeen: false,
-    sourceId: badge.type,
-    sourceType: 'badge',
-    sourceUpdateType: 'created',
-    sourceUserName: MANIFOLD_USER_NAME,
-    sourceUserUsername: MANIFOLD_USER_USERNAME,
-    sourceUserAvatarUrl: MANIFOLD_AVATAR_URL,
-    sourceText: `You earned a new ${badge.name} badge!`,
-    sourceSlug: `/${user.username}?show=badges&badge=${badge.type}`,
-    sourceTitle: badge.name,
-    data: {
-      badge,
-    },
-  }
-  return await notificationRef.set(removeUndefinedProps(notification))
-
-  // TODO send email notification
-}
-
-export const createMarketClosedNotification = async (
-  contract: Contract,
-  creator: User,
-  privateUser: PrivateUser,
-  idempotencyKey: string
-) => {
-  const notificationRef = firestore
-    .collection(`/users/${creator.id}/notifications`)
-    .doc(idempotencyKey)
-  const notification: Notification = {
-    id: idempotencyKey,
-    userId: creator.id,
-    reason: 'your_contract_closed',
-    createdTime: Date.now(),
-    isSeen: false,
-    sourceId: contract.id,
-    sourceType: 'contract',
-    sourceUpdateType: 'closed',
-    sourceContractId: contract?.id,
-    sourceUserName: creator.name,
-    sourceUserUsername: creator.username,
-    sourceUserAvatarUrl: creator.avatarUrl,
-    sourceText: contract.closeTime?.toString() ?? new Date().toString(),
-    sourceContractCreatorUsername: creator.username,
-    sourceContractTitle: contract.question,
-    sourceContractSlug: contract.slug,
-    sourceSlug: contract.slug,
-    sourceTitle: contract.question,
-  }
-  await notificationRef.set(removeUndefinedProps(notification))
-  await sendMarketCloseEmail(
-    'your_contract_closed',
-    creator,
-    privateUser,
-    contract
-  )
-}
--- a/functions/src/create-post.ts
+++ b/functions/src/create-post.ts
@ -3,17 +3,10 @@ import * as admin from 'firebase-admin'
 import { getUser } from './utils'
 import { slugify } from '../../common/util/slugify'
 import { randomString } from '../../common/util/random'
-import {
-  Post,
-  MAX_POST_TITLE_LENGTH,
-  MAX_POST_SUBTITLE_LENGTH,
-} from '../../common/post'
+import { Post, MAX_POST_TITLE_LENGTH } from '../../common/post'
 import { APIError, newEndpoint, validate } from './api'
 import { JSONContent } from '@tiptap/core'
 import { z } from 'zod'
-import { removeUndefinedProps } from '../../common/util/object'
-import { createMarketHelper } from './create-market'
-import { DAY_MS } from '../../common/util/time'

 const contentSchema: z.ZodType<JSONContent> = z.lazy(() =>
  z.intersection(
@ -40,21 +33,13 @@ const contentSchema: z.ZodType<JSONContent> = z.lazy(() =>

 const postSchema = z.object({
  title: z.string().min(1).max(MAX_POST_TITLE_LENGTH),
-  subtitle: z.string().min(1).max(MAX_POST_SUBTITLE_LENGTH),
  content: contentSchema,
  groupId: z.string().optional(),
-
-  // Date doc fields:
-  bounty: z.number().optional(),
-  birthday: z.number().optional(),
-  type: z.string().optional(),
-  question: z.string().optional(),
 })

 export const createpost = newEndpoint({}, async (req, auth) => {
  const firestore = admin.firestore()
-  const { title, subtitle, content, groupId, question, ...otherProps } =
-    validate(postSchema, req.body)
+  const { title, content, groupId } = validate(postSchema, req.body)

  const creator = await getUser(auth.uid)
  if (!creator)
@ -66,45 +51,14 @@ export const createpost = newEndpoint({}, async (req, auth) => {

  const postRef = firestore.collection('posts').doc()

-  // If this is a date doc, create a market for it.
-  let contractSlug
-  if (question) {
-    const closeTime = Date.now() + DAY_MS * 30 * 3
-
-    try {
-      const result = await createMarketHelper(
-        {
-          question,
-          closeTime,
-          outcomeType: 'BINARY',
-          visibility: 'unlisted',
-          initialProb: 50,
-          // Dating group!
-          groupId: 'j3ZE8fkeqiKmRGumy3O1',
-        },
-        auth
-      )
-      contractSlug = result.slug
-    } catch (e) {
-      console.error(e)
-    }
-  }
-
-  const post: Post = removeUndefinedProps({
-    ...otherProps,
+  const post: Post = {
    id: postRef.id,
    creatorId: creator.id,
    slug,
    title,
-    subtitle,
    createdTime: Date.now(),
    content: content,
-    contractSlug,
-    creatorName: creator.name,
-    creatorUsername: creator.username,
-    creatorAvatarUrl: creator.avatarUrl,
-    itemType: 'post',
-  })
+  }

  await postRef.create(post)
  if (groupId) {
--- a/functions/src/create-user.ts
+++ b/functions/src/create-user.ts
@ -69,8 +69,6 @@ export const createuser = newEndpoint(opts, async (req, auth) => {
    followerCountCached: 0,
    followedCategories: DEFAULT_CATEGORIES,
    shouldShowWelcome: true,
-    fractionResolvedCorrectly: 1,
-    achievements: {},
  }

  await firestore.collection('users').doc(auth.uid).create(user)
--- a/functions/src/drizzle-liquidity.ts
+++ b/functions/src/drizzle-liquidity.ts
@ -1,69 +0,0 @@
-import * as functions from 'firebase-functions'
-import * as admin from 'firebase-admin'
-
-import { CPMMContract } from '../../common/contract'
-import { batchedWaitAll } from '../../common/util/promise'
-import { APIError } from '../../common/api'
-import { addCpmmLiquidity } from '../../common/calculate-cpmm'
-import { formatMoneyWithDecimals } from '../../common/util/format'
-
-const firestore = admin.firestore()
-
-export const drizzleLiquidity = async () => {
-  const snap = await firestore
-    .collection('contracts')
-    .where('subsidyPool', '>', 1e-7)
-    .get()
-
-  const contractIds = snap.docs.map((doc) => doc.id)
-  console.log('found', contractIds.length, 'markets to drizzle')
-  console.log()
-
-  await batchedWaitAll(
-    contractIds.map((cid) => () => drizzleMarket(cid)),
-    10
-  )
-}
-
-export const drizzleLiquidityScheduler = functions.pubsub
-  .schedule('* * * * *') // every minute
-  .onRun(drizzleLiquidity)
-
-const drizzleMarket = async (contractId: string) => {
-  await firestore.runTransaction(async (trans) => {
-    const snap = await trans.get(firestore.doc(`contracts/${contractId}`))
-    const contract = snap.data() as CPMMContract
-    const { subsidyPool, pool, p, slug, popularityScore } = contract
-    if ((subsidyPool ?? 0) < 1e-7) return
-
-    const r = Math.random()
-    const logPopularity = Math.log10((popularityScore ?? 0) + 1)
-    const v = Math.max(1, Math.min(5, logPopularity))
-    const amount = subsidyPool <= 0.5 ? subsidyPool : r * v * 0.01 * subsidyPool
-
-    const { newPool, newP } = addCpmmLiquidity(pool, p, amount)
-
-    if (!isFinite(newP)) {
-      throw new APIError(
-        500,
-        'Liquidity injection rejected due to overflow error.'
-      )
-    }
-
-    await trans.update(firestore.doc(`contracts/${contract.id}`), {
-      pool: newPool,
-      p: newP,
-      subsidyPool: subsidyPool - amount,
-    })
-
-    console.log(
-      'added subsidy',
-      formatMoneyWithDecimals(amount),
-      'of',
-      formatMoneyWithDecimals(subsidyPool),
-      'pool to',
-      slug
-    )
-    console.log()
-  })
-}
--- a/functions/src/email-templates/market-close.html
+++ b/functions/src/email-templates/market-close.html
@ -483,7 +483,11 @@
                        color: #999;
                        text-decoration: underline;
                        margin: 0;
-                      ">our Discord</a>!
+                      ">our Discord</a>! Or,
+                  <a href="{{unsubscribeUrl}}" style="
+                                          color: inherit;
+                                          text-decoration: none;
+                                        " target="_blank">click here to unsubscribe from this type of notification</a>.
                </td>
              </tr>
            </table>
--- a/functions/src/email-templates/weekly-portfolio-update.html
+++ b/functions/src/email-templates/weekly-portfolio-update.html
@ -320,7 +320,7 @@
                                                    style="line-height: 24px; margin: 10px 0; margin-top: 20px; margin-bottom: 20px;"
                                                    data-testid="4XoHRGw1Y">
                                                    <span style="color:#000000;font-family:Arial, Helvetica, sans-serif;font-size:18px;">
-                                                    And here's some recent changes in your investments:
+                                                    And here's some of the biggest changes in your portfolio:
                                                    </span>
                                                </p>
                                            </div>
--- a/functions/src/emails.ts
+++ b/functions/src/emails.ts
@ -12,7 +12,7 @@ import { getValueFromBucket } from '../../common/calculate-dpm'
 import { formatNumericProbability } from '../../common/pseudo-numeric'

 import { sendTemplateEmail, sendTextEmail } from './send-email'
-import { contractUrl, getUser, log } from './utils'
+import { contractUrl, getUser } from './utils'
 import { buildCardUrl, getOpenGraphProps } from '../../common/contract-details'
 import { notification_reason_types } from '../../common/notification'
 import { Dictionary } from 'lodash'
@ -20,7 +20,7 @@ import { getNotificationDestinationsForUser } from '../../common/user-notificati
 import {
  PerContractInvestmentsData,
  OverallPerformanceData,
-} from './weekly-portfolio-emails'
+} from 'functions/src/weekly-portfolio-emails'

 export const sendMarketResolutionEmail = async (
  reason: notification_reason_types,
@ -212,16 +212,20 @@ export const sendOneWeekBonusEmail = async (
  user: User,
  privateUser: PrivateUser
 ) => {
-  if (!privateUser || !privateUser.email) return
+  if (
+    !privateUser ||
+    !privateUser.email ||
+    !privateUser.notificationPreferences.onboarding_flow.includes('email')
+  )
+    return

  const { name } = user
  const firstName = name.split(' ')[0]

-  const { unsubscribeUrl, sendToEmail } = getNotificationDestinationsForUser(
+  const { unsubscribeUrl } = getNotificationDestinationsForUser(
    privateUser,
    'onboarding_flow'
  )
-  if (!sendToEmail) return

  return await sendTemplateEmail(
    privateUser.email,
@ -243,15 +247,19 @@ export const sendCreatorGuideEmail = async (
  privateUser: PrivateUser,
  sendTime: string
 ) => {
-  if (!privateUser || !privateUser.email) return
+  if (
+    !privateUser ||
+    !privateUser.email ||
+    !privateUser.notificationPreferences.onboarding_flow.includes('email')
+  )
+    return

  const { name } = user
  const firstName = name.split(' ')[0]
-  const { unsubscribeUrl, sendToEmail } = getNotificationDestinationsForUser(
+  const { unsubscribeUrl } = getNotificationDestinationsForUser(
    privateUser,
    'onboarding_flow'
  )
-  if (!sendToEmail) return
  return await sendTemplateEmail(
    privateUser.email,
    'Create your own prediction market',
@ -271,16 +279,22 @@ export const sendThankYouEmail = async (
  user: User,
  privateUser: PrivateUser
 ) => {
-  if (!privateUser || !privateUser.email) return
+  if (
+    !privateUser ||
+    !privateUser.email ||
+    !privateUser.notificationPreferences.thank_you_for_purchases.includes(
+      'email'
+    )
+  )
+    return

  const { name } = user
  const firstName = name.split(' ')[0]
-  const { unsubscribeUrl, sendToEmail } = getNotificationDestinationsForUser(
+  const { unsubscribeUrl } = getNotificationDestinationsForUser(
    privateUser,
    'thank_you_for_purchases'
  )

-  if (!sendToEmail) return
  return await sendTemplateEmail(
    privateUser.email,
    'Thanks for your Manifold purchase',
@ -301,7 +315,12 @@ export const sendMarketCloseEmail = async (
  privateUser: PrivateUser,
  contract: Contract
 ) => {
-  if (!privateUser.email) return
+  const { sendToEmail, unsubscribeUrl } = getNotificationDestinationsForUser(
+    privateUser,
+    reason
+  )
+
+  if (!privateUser.email || !sendToEmail) return

  const { username, name, id: userId } = user
  const firstName = name.split(' ')[0]
@ -310,7 +329,6 @@ export const sendMarketCloseEmail = async (

  const url = `https://${DOMAIN}/${username}/${slug}`

-  // We ignore if they were able to unsubscribe from market close emails, this is a necessary email
  return await sendTemplateEmail(
    privateUser.email,
    'Your market has closed',
@ -318,7 +336,7 @@ export const sendMarketCloseEmail = async (
    {
      question,
      url,
-      unsubscribeUrl: '',
+      unsubscribeUrl,
      userId,
      name: firstName,
      volume: formatMoney(volume),
@ -448,13 +466,17 @@ export const sendInterestingMarketsEmail = async (
  contractsToSend: Contract[],
  deliveryTime?: string
 ) => {
-  if (!privateUser || !privateUser.email) return
+  if (
+    !privateUser ||
+    !privateUser.email ||
+    !privateUser.notificationPreferences.trending_markets.includes('email')
+  )
+    return

-  const { unsubscribeUrl, sendToEmail } = getNotificationDestinationsForUser(
+  const { unsubscribeUrl } = getNotificationDestinationsForUser(
    privateUser,
    'trending_markets'
  )
-  if (!sendToEmail) return

  const { name } = user
  const firstName = name.split(' ')[0]
@ -598,15 +620,18 @@ export const sendWeeklyPortfolioUpdateEmail = async (
  investments: PerContractInvestmentsData[],
  overallPerformance: OverallPerformanceData
 ) => {
-  if (!privateUser || !privateUser.email) return
+  if (
+    !privateUser ||
+    !privateUser.email ||
+    !privateUser.notificationPreferences.profit_loss_updates.includes('email')
+  )
+    return

-  const { unsubscribeUrl, sendToEmail } = getNotificationDestinationsForUser(
+  const { unsubscribeUrl } = getNotificationDestinationsForUser(
    privateUser,
    'profit_loss_updates'
  )

-  if (!sendToEmail) return
-
  const { name } = user
  const firstName = name.split(' ')[0]
  const templateData: Record<string, string> = {
@ -618,8 +643,8 @@ export const sendWeeklyPortfolioUpdateEmail = async (
    templateData[`question${i + 1}Title`] = investment.questionTitle
    templateData[`question${i + 1}Url`] = investment.questionUrl
    templateData[`question${i + 1}Prob`] = investment.questionProb
-    templateData[`question${i + 1}Change`] = formatMoney(investment.profit)
-    templateData[`question${i + 1}ChangeStyle`] = investment.profitStyle
+    templateData[`question${i + 1}Change`] = investment.questionChange
+    templateData[`question${i + 1}ChangeStyle`] = investment.questionChangeStyle
  })

  await sendTemplateEmail(
@ -631,5 +656,4 @@ export const sendWeeklyPortfolioUpdateEmail = async (
      : 'portfolio-update',
    templateData
  )
-  log('Sent portfolio update email to', privateUser.email)
 }
--- a/functions/src/helpers/add-house-subsidy.ts
+++ b/functions/src/helpers/add-house-subsidy.ts
@ -1,42 +0,0 @@
-import * as admin from 'firebase-admin'
-
-import { CPMMContract } from '../../../common/contract'
-import { isProd } from '../utils'
-import {
-  DEV_HOUSE_LIQUIDITY_PROVIDER_ID,
-  HOUSE_LIQUIDITY_PROVIDER_ID,
-} from '../../../common/antes'
-import { getNewLiquidityProvision } from '../../../common/add-liquidity'
-
-const firestore = admin.firestore()
-
-export const addHouseSubsidy = (contractId: string, amount: number) => {
-  return firestore.runTransaction(async (transaction) => {
-    const newLiquidityProvisionDoc = firestore
-      .collection(`contracts/${contractId}/liquidity`)
-      .doc()
-
-    const providerId = isProd()
-      ? HOUSE_LIQUIDITY_PROVIDER_ID
-      : DEV_HOUSE_LIQUIDITY_PROVIDER_ID
-
-    const contractDoc = firestore.doc(`contracts/${contractId}`)
-    const snap = await contractDoc.get()
-    const contract = snap.data() as CPMMContract
-
-    const { newLiquidityProvision, newTotalLiquidity, newSubsidyPool } =
-      getNewLiquidityProvision(
-        providerId,
-        amount,
-        contract,
-        newLiquidityProvisionDoc.id
-      )
-
-    transaction.update(contractDoc, {
-      subsidyPool: newSubsidyPool,
-      totalLiquidity: newTotalLiquidity,
-    } as Partial<CPMMContract>)
-
-    transaction.create(newLiquidityProvisionDoc, newLiquidityProvision)
-  })
-}
--- a/functions/src/index.ts
+++ b/functions/src/index.ts
@ -9,7 +9,7 @@ export * from './on-create-user'
 export * from './on-create-bet'
 export * from './on-create-comment-on-contract'
 export * from './on-view'
-export { scheduleUpdateMetrics } from './update-metrics'
+export * from './update-metrics'
 export * from './update-stats'
 export * from './update-loans'
 export * from './backup-db'
@ -31,7 +31,6 @@ export * from './reset-weekly-emails-flags'
 export * from './on-update-contract-follow'
 export * from './on-update-like'
 export * from './weekly-portfolio-emails'
-export * from './drizzle-liquidity'

 // v2
 export * from './health'
@ -45,14 +44,14 @@ export * from './sell-bet'
 export * from './sell-shares'
 export * from './claim-manalink'
 export * from './create-market'
+export * from './add-liquidity'
+export * from './withdraw-liquidity'
 export * from './create-group'
 export * from './resolve-market'
 export * from './unsubscribe'
 export * from './stripe'
 export * from './mana-bonus-email'
 export * from './close-market'
-export * from './update-comment-bounty'
-export * from './add-subsidy'

 import { health } from './health'
 import { transact } from './transact'
@ -65,8 +64,8 @@ import { sellbet } from './sell-bet'
 import { sellshares } from './sell-shares'
 import { claimmanalink } from './claim-manalink'
 import { createmarket } from './create-market'
-import { createcomment } from './create-comment'
-import { addcommentbounty, awardcommentbounty } from './update-comment-bounty'
+import { addliquidity } from './add-liquidity'
+import { withdrawliquidity } from './withdraw-liquidity'
 import { creategroup } from './create-group'
 import { resolvemarket } from './resolve-market'
 import { closemarket } from './close-market'
@ -76,8 +75,6 @@ import { getcurrentuser } from './get-current-user'
 import { acceptchallenge } from './accept-challenge'
 import { createpost } from './create-post'
 import { savetwitchcredentials } from './save-twitch-credentials'
-import { updatemetrics } from './update-metrics'
-import { addsubsidy } from './add-subsidy'

 const toCloudFunction = ({ opts, handler }: EndpointDefinition) => {
  return onRequest(opts, handler as any)
@ -93,10 +90,8 @@ const sellBetFunction = toCloudFunction(sellbet)
 const sellSharesFunction = toCloudFunction(sellshares)
 const claimManalinkFunction = toCloudFunction(claimmanalink)
 const createMarketFunction = toCloudFunction(createmarket)
-const addSubsidyFunction = toCloudFunction(addsubsidy)
-const addCommentBounty = toCloudFunction(addcommentbounty)
-const createCommentFunction = toCloudFunction(createcomment)
-const awardCommentBounty = toCloudFunction(awardcommentbounty)
+const addLiquidityFunction = toCloudFunction(addliquidity)
+const withdrawLiquidityFunction = toCloudFunction(withdrawliquidity)
 const createGroupFunction = toCloudFunction(creategroup)
 const resolveMarketFunction = toCloudFunction(resolvemarket)
 const closeMarketFunction = toCloudFunction(closemarket)
@ -107,7 +102,6 @@ const getCurrentUserFunction = toCloudFunction(getcurrentuser)
 const acceptChallenge = toCloudFunction(acceptchallenge)
 const createPostFunction = toCloudFunction(createpost)
 const saveTwitchCredentials = toCloudFunction(savetwitchcredentials)
-const updateMetricsFunction = toCloudFunction(updatemetrics)

 export {
  healthFunction as health,
@ -121,7 +115,8 @@ export {
  sellSharesFunction as sellshares,
  claimManalinkFunction as claimmanalink,
  createMarketFunction as createmarket,
-  addSubsidyFunction as addsubsidy,
+  addLiquidityFunction as addliquidity,
+  withdrawLiquidityFunction as withdrawliquidity,
  createGroupFunction as creategroup,
  resolveMarketFunction as resolvemarket,
  closeMarketFunction as closemarket,
@ -132,8 +127,4 @@ export {
  acceptChallenge as acceptchallenge,
  createPostFunction as createpost,
  saveTwitchCredentials as savetwitchcredentials,
-  createCommentFunction as createcomment,
-  addCommentBounty as addcommentbounty,
-  awardCommentBounty as awardcommentbounty,
-  updateMetricsFunction as updatemetrics,
 }
--- a/functions/src/market-close-notifications.ts
+++ b/functions/src/market-close-notifications.ts
@ -3,10 +3,8 @@ import * as admin from 'firebase-admin'

 import { Contract } from '../../common/contract'
 import { getPrivateUser, getUserByUsername } from './utils'
-import { createMarketClosedNotification } from './create-notification'
-import { DAY_MS } from '../../common/util/time'
+import { createNotification } from './create-notification'

-const SEND_NOTIFICATIONS_EVERY_DAYS = 5
 export const marketCloseNotifications = functions
  .runWith({ secrets: ['MAILGUN_KEY'] })
  .pubsub.schedule('every 1 hours')
@ -16,31 +14,31 @@ export const marketCloseNotifications = functions

 const firestore = admin.firestore()

-export async function sendMarketCloseEmails() {
+async function sendMarketCloseEmails() {
  const contracts = await firestore.runTransaction(async (transaction) => {
    const snap = await transaction.get(
      firestore.collection('contracts').where('isResolved', '!=', true)
    )
-    const contracts = snap.docs.map((doc) => doc.data() as Contract)
-    const now = Date.now()
-    const closeContracts = contracts.filter(
-      (contract) =>
-        contract.closeTime &&
-        contract.closeTime < now &&
-        shouldSendFirstOrFollowUpCloseNotification(contract)
-    )

-    await Promise.all(
-      closeContracts.map(async (contract) => {
-        await transaction.update(
-          firestore.collection('contracts').doc(contract.id),
-          {
-            closeEmailsSent: admin.firestore.FieldValue.increment(1),
-          }
+    return snap.docs
+      .map((doc) => {
+        const contract = doc.data() as Contract
+
+        if (
+          contract.resolution ||
+          (contract.closeEmailsSent ?? 0) >= 1 ||
+          contract.closeTime === undefined ||
+          (contract.closeTime ?? 0) > Date.now()
        )
+          return undefined
+
+        transaction.update(doc.ref, {
+          closeEmailsSent: (contract.closeEmailsSent ?? 0) + 1,
        })
-    )
-    return closeContracts
+
+        return contract
+      })
+      .filter((x) => !!x) as Contract[]
  })

  for (const contract of contracts) {
@ -57,40 +55,14 @@ export async function sendMarketCloseEmails() {
    const privateUser = await getPrivateUser(user.id)
    if (!privateUser) continue

-    await createMarketClosedNotification(
-      contract,
+    await createNotification(
+      contract.id,
+      'contract',
+      'closed',
      user,
-      privateUser,
-      contract.id + '-closed-at-' + contract.closeTime
+      contract.id + '-closed-at-' + contract.closeTime,
+      contract.closeTime?.toString() ?? new Date().toString(),
+      { contract }
    )
  }
 }
-
-// The downside of this approach is if this function goes down for the entire
-// day of a multiple of the time period after the market has closed, it won't
-// keep sending them notifications bc when it comes back online the time period will have passed
-function shouldSendFirstOrFollowUpCloseNotification(contract: Contract) {
-  if (!contract.closeEmailsSent || contract.closeEmailsSent === 0) return true
-  const { closedMultipleOfNDaysAgo, fullTimePeriodsSinceClose } =
-    marketClosedMultipleOfNDaysAgo(contract)
-  return (
-    contract.closeEmailsSent > 0 &&
-    closedMultipleOfNDaysAgo &&
-    contract.closeEmailsSent === fullTimePeriodsSinceClose
-  )
-}
-
-function marketClosedMultipleOfNDaysAgo(contract: Contract) {
-  const now = Date.now()
-  const closeTime = contract.closeTime
-  if (!closeTime)
-    return { closedMultipleOfNDaysAgo: false, fullTimePeriodsSinceClose: 0 }
-  const daysSinceClose = Math.floor((now - closeTime) / DAY_MS)
-  return {
-    closedMultipleOfNDaysAgo:
-      daysSinceClose % SEND_NOTIFICATIONS_EVERY_DAYS == 0,
-    fullTimePeriodsSinceClose: Math.floor(
-      daysSinceClose / SEND_NOTIFICATIONS_EVERY_DAYS
-    ),
-  }
-}
--- a/functions/src/on-create-bet.ts
+++ b/functions/src/on-create-bet.ts
@ -12,7 +12,6 @@ import {
  revalidateStaticProps,
 } from './utils'
 import {
-  createBadgeAwardedNotification,
  createBetFillNotification,
  createBettingStreakBonusNotification,
  createUniqueBettorBonusNotification,
@ -25,7 +24,6 @@ import {
  BETTING_STREAK_BONUS_MAX,
  BETTING_STREAK_RESET_HOUR,
  UNIQUE_BETTOR_BONUS_AMOUNT,
-  UNIQUE_BETTOR_LIQUIDITY,
 } from '../../common/economy'
 import {
  DEV_HOUSE_LIQUIDITY_PROVIDER_ID,
@ -35,11 +33,6 @@ import { APIError } from '../../common/api'
 import { User } from '../../common/user'
 import { DAY_MS } from '../../common/util/time'
 import { BettingStreakBonusTxn, UniqueBettorBonusTxn } from '../../common/txn'
-import { addHouseSubsidy } from './helpers/add-house-subsidy'
-import {
-  StreakerBadge,
-  streakerBadgeRarityThresholds,
-} from '../../common/badge'

 const firestore = admin.firestore()
 const BONUS_START_DATE = new Date('2022-07-13T15:30:00.000Z').getTime()
@ -110,7 +103,7 @@ const updateBettingStreak = async (

    const newBettingStreak = (bettor?.currentBettingStreak ?? 0) + 1
    // Otherwise, add 1 to their betting streak
-    trans.update(userDoc, {
+    await trans.update(userDoc, {
      currentBettingStreak: newBettingStreak,
      lastBetTime: bet.createdTime,
    })
@ -150,7 +143,7 @@ const updateBettingStreak = async (
    log('message:', result.message)
    return
  }
-  if (result.txn) {
+  if (result.txn)
    await createBettingStreakBonusNotification(
      user,
      result.txn.id,
@ -160,8 +153,6 @@ const updateBettingStreak = async (
      newBettingStreak,
      eventId
    )
-    await handleBettingStreakBadgeAward(user, newBettingStreak)
-  }
 }

 const updateUniqueBettorsAndGiveCreatorBonus = async (
@ -200,7 +191,7 @@ const updateUniqueBettorsAndGiveCreatorBonus = async (
        log(`Got ${previousUniqueBettorIds} unique bettors`)
        isNewUniqueBettor && log(`And a new unique bettor ${bettor.id}`)

-        trans.update(contractDoc, {
+        await trans.update(contractDoc, {
          uniqueBettorIds: newUniqueBettorIds,
          uniqueBettorCount: newUniqueBettorIds.length,
        })
@ -213,13 +204,8 @@ const updateUniqueBettorsAndGiveCreatorBonus = async (
      return { newUniqueBettorIds }
    }
  )
-
  if (!newUniqueBettorIds) return

-  if (oldContract.mechanism === 'cpmm-1') {
-    await addHouseSubsidy(oldContract.id, UNIQUE_BETTOR_LIQUIDITY)
-  }
-
  const bonusTxnDetails = {
    contractId: oldContract.id,
    uniqueNewBettorId: bettor.id,
@ -229,9 +215,7 @@ const updateUniqueBettorsAndGiveCreatorBonus = async (
    : DEV_HOUSE_LIQUIDITY_PROVIDER_ID
  const fromSnap = await firestore.doc(`users/${fromUserId}`).get()
  if (!fromSnap.exists) throw new APIError(400, 'From user not found.')
-
  const fromUser = fromSnap.data() as User
-
  const result = await firestore.runTransaction(async (trans) => {
    const bonusTxn: TxnData = {
      fromId: fromUser.id,
@ -244,9 +228,7 @@ const updateUniqueBettorsAndGiveCreatorBonus = async (
      description: JSON.stringify(bonusTxnDetails),
      data: bonusTxnDetails,
    } as Omit<UniqueBettorBonusTxn, 'id' | 'createdTime'>
-
    const { status, message, txn } = await runTxn(trans, bonusTxn)
-
    return { status, newUniqueBettorIds, message, txn }
  })

@ -314,39 +296,3 @@ const notifyFills = async (
 const currentDateBettingStreakResetTime = () => {
  return new Date().setUTCHours(BETTING_STREAK_RESET_HOUR, 0, 0, 0)
 }
-
-async function handleBettingStreakBadgeAward(
-  user: User,
-  newBettingStreak: number
-) {
-  const alreadyHasBadgeForFirstStreak =
-    user.achievements?.streaker?.badges.some(
-      (badge) => badge.data.totalBettingStreak === 1
-    )
-  // TODO: check if already awarded 50th streak as well
-  if (newBettingStreak === 1 && alreadyHasBadgeForFirstStreak) return
-
-  if (streakerBadgeRarityThresholds.includes(newBettingStreak)) {
-    const badge = {
-      type: 'STREAKER',
-      name: 'Streaker',
-      data: {
-        totalBettingStreak: newBettingStreak,
-      },
-      createdTime: Date.now(),
-    } as StreakerBadge
-    // update user
-    await firestore
-      .collection('users')
-      .doc(user.id)
-      .update({
-        achievements: {
-          ...user.achievements,
-          streaker: {
-            badges: [...(user.achievements?.streaker?.badges ?? []), badge],
-          },
-        },
-      })
-    await createBadgeAwardedNotification(user, badge)
-  }
-}
--- a/functions/src/on-create-contract.ts
+++ b/functions/src/on-create-contract.ts
@ -1,20 +1,11 @@
 import * as functions from 'firebase-functions'

-import { getUser, getValues } from './utils'
-import {
-  createBadgeAwardedNotification,
-  createNewContractNotification,
-} from './create-notification'
+import { getUser } from './utils'
+import { createNewContractNotification } from './create-notification'
 import { Contract } from '../../common/contract'
 import { parseMentions, richTextToString } from '../../common/util/parse'
 import { JSONContent } from '@tiptap/core'
 import { addUserToContractFollowers } from './follow-market'
-import { User } from '../../common/user'
-import * as admin from 'firebase-admin'
-import {
-  MarketCreatorBadge,
-  marketCreatorBadgeRarityThresholds,
-} from '../../common/badge'

 export const onCreateContract = functions
  .runWith({ secrets: ['MAILGUN_KEY'] })
@ -37,43 +28,4 @@ export const onCreateContract = functions
      richTextToString(desc),
      mentioned
    )
-    await handleMarketCreatorBadgeAward(contractCreator)
  })
-
-const firestore = admin.firestore()
-
-async function handleMarketCreatorBadgeAward(contractCreator: User) {
-  // get all contracts by user and calculate size of array
-  const contracts = await getValues<Contract>(
-    firestore
-      .collection(`contracts`)
-      .where('creatorId', '==', contractCreator.id)
-      .where('resolution', '!=', 'CANCEL')
-  )
-  if (marketCreatorBadgeRarityThresholds.includes(contracts.length)) {
-    const badge = {
-      type: 'MARKET_CREATOR',
-      name: 'Market Creator',
-      data: {
-        totalContractsCreated: contracts.length,
-      },
-      createdTime: Date.now(),
-    } as MarketCreatorBadge
-    // update user
-    await firestore
-      .collection('users')
-      .doc(contractCreator.id)
-      .update({
-        achievements: {
-          ...contractCreator.achievements,
-          marketCreator: {
-            badges: [
-              ...(contractCreator.achievements?.marketCreator?.badges ?? []),
-              badge,
-            ],
-          },
-        },
-      })
-    await createBadgeAwardedNotification(contractCreator, badge)
-  }
-}
--- a/functions/src/on-create-liquidity-provision.ts
+++ b/functions/src/on-create-liquidity-provision.ts
@ -1,6 +1,6 @@
 import * as functions from 'firebase-functions'
 import { getContract, getUser, log } from './utils'
-import { createFollowOrMarketSubsidizedNotification } from './create-notification'
+import { createNotification } from './create-notification'
 import { LiquidityProvision } from '../../common/liquidity-provision'
 import { addUserToContractFollowers } from './follow-market'
 import { FIXED_ANTE } from '../../common/economy'
@ -36,7 +36,7 @@ export const onCreateLiquidityProvision = functions.firestore
    if (!liquidityProvider) throw new Error('Could not find liquidity provider')
    await addUserToContractFollowers(contract.id, liquidityProvider.id)

-    await createFollowOrMarketSubsidizedNotification(
+    await createNotification(
      contract.id,
      'liquidity',
      'created',
--- a/functions/src/on-follow-user.ts
+++ b/functions/src/on-follow-user.ts
@ -2,7 +2,7 @@ import * as functions from 'firebase-functions'
 import * as admin from 'firebase-admin'

 import { getUser } from './utils'
-import { createFollowOrMarketSubsidizedNotification } from './create-notification'
+import { createNotification } from './create-notification'
 import { FieldValue } from 'firebase-admin/firestore'

 export const onFollowUser = functions.firestore
@ -23,7 +23,7 @@ export const onFollowUser = functions.firestore
      followerCountCached: FieldValue.increment(1),
    })

-    await createFollowOrMarketSubsidizedNotification(
+    await createNotification(
      followingUser.id,
      'follow',
      'created',
--- a/functions/src/on-update-contract.ts
+++ b/functions/src/on-update-contract.ts
@ -1,110 +1,33 @@
 import * as functions from 'firebase-functions'
-import { getUser, getValues } from './utils'
-import {
-  createBadgeAwardedNotification,
-  createCommentOrAnswerOrUpdatedContractNotification,
-} from './create-notification'
+import { getUser } from './utils'
+import { createCommentOrAnswerOrUpdatedContractNotification } from './create-notification'
 import { Contract } from '../../common/contract'
-import { Bet } from '../../common/bet'
-import * as admin from 'firebase-admin'
-import { ContractComment } from '../../common/comment'
-import { scoreCommentorsAndBettors } from '../../common/scoring'
-import {
-  MINIMUM_UNIQUE_BETTORS_FOR_PROVEN_CORRECT_BADGE,
-  ProvenCorrectBadge,
-} from '../../common/badge'
-import { GroupContractDoc } from '../../common/group'

 export const onUpdateContract = functions.firestore
  .document('contracts/{contractId}')
  .onUpdate(async (change, context) => {
    const contract = change.after.data() as Contract
-    const previousContract = change.before.data() as Contract
    const { eventId } = context
-    const { closeTime, question } = contract

-    if (!previousContract.isResolved && contract.isResolved) {
-      // No need to notify users of resolution, that's handled in resolve-market
-      return await handleResolvedContract(contract)
-    } else if (previousContract.groupSlugs !== contract.groupSlugs) {
-      await handleContractGroupUpdated(previousContract, contract)
-    } else if (
-      previousContract.closeTime !== closeTime ||
-      previousContract.question !== question
-    ) {
-      await handleUpdatedCloseTime(previousContract, contract, eventId)
-    }
-  })
-
-async function handleResolvedContract(contract: Contract) {
-  if (
-    (contract.uniqueBettorCount ?? 0) <
-      MINIMUM_UNIQUE_BETTORS_FOR_PROVEN_CORRECT_BADGE ||
-    contract.resolution === 'CANCEL'
-  )
-    return
-
-  // get all bets on this contract
-  const bets = await getValues<Bet>(
-    firestore.collection(`contracts/${contract.id}/bets`)
-  )
-
-  // get comments on this contract
-  const comments = await getValues<ContractComment>(
-    firestore.collection(`contracts/${contract.id}/comments`)
-  )
-
-  const { topCommentId, profitById, commentsById, betsById, topCommentBetId } =
-    scoreCommentorsAndBettors(contract, bets, comments)
-  if (topCommentBetId && profitById[topCommentBetId] > 0) {
-    // award proven correct badge to user
-    const comment = commentsById[topCommentId]
-    const bet = betsById[topCommentBetId]
-
-    const user = await getUser(comment.userId)
-    if (!user) return
-    const newProvenCorrectBadge = {
-      createdTime: Date.now(),
-      type: 'PROVEN_CORRECT',
-      name: 'Proven Correct',
-      data: {
-        contractSlug: contract.slug,
-        contractCreatorUsername: contract.creatorUsername,
-        commentId: comment.id,
-        betAmount: bet.amount,
-        contractTitle: contract.question,
-      },
-    } as ProvenCorrectBadge
-    // update user
-    await firestore
-      .collection('users')
-      .doc(user.id)
-      .update({
-        achievements: {
-          ...user.achievements,
-          provenCorrect: {
-            badges: [
-              ...(user.achievements?.provenCorrect?.badges ?? []),
-              newProvenCorrectBadge,
-            ],
-          },
-        },
-      })
-    await createBadgeAwardedNotification(user, newProvenCorrectBadge)
-  }
-}
-
-async function handleUpdatedCloseTime(
-  previousContract: Contract,
-  contract: Contract,
-  eventId: string
-) {
    const contractUpdater = await getUser(contract.creatorId)
    if (!contractUpdater) throw new Error('Could not find contract updater')
+
+    const previousValue = change.before.data() as Contract
+
+    // Resolution is handled in resolve-market.ts
+    if (!previousValue.isResolved && contract.isResolved) return
+
+    if (
+      previousValue.closeTime !== contract.closeTime ||
+      previousValue.question !== contract.question
+    ) {
      let sourceText = ''
-  if (previousContract.closeTime !== contract.closeTime && contract.closeTime) {
+      if (
+        previousValue.closeTime !== contract.closeTime &&
+        contract.closeTime
+      ) {
        sourceText = contract.closeTime.toString()
-  } else if (previousContract.question !== contract.question) {
+      } else if (previousValue.question !== contract.question) {
        sourceText = contract.question
      }

@ -117,44 +40,5 @@ async function handleUpdatedCloseTime(
        sourceText,
        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()
+  })
--- a/functions/src/on-update-user.ts
+++ b/functions/src/on-update-user.ts
@ -5,6 +5,8 @@ import { HOUSE_LIQUIDITY_PROVIDER_ID } from '../../common/antes'
 import { createReferralNotification } from './create-notification'
 import { ReferralTxn } from '../../common/txn'
 import { Contract } from '../../common/contract'
+import { LimitBet } from '../../common/bet'
+import { QuerySnapshot } from 'firebase-admin/firestore'
 import { Group } from '../../common/group'
 import { REFERRAL_AMOUNT } from '../../common/economy'
 const firestore = admin.firestore()
@ -19,6 +21,10 @@ export const onUpdateUser = functions.firestore
    if (prevUser.referredByUserId !== user.referredByUserId) {
      await handleUserUpdatedReferral(user, eventId)
    }
+
+    if (user.balance <= 0) {
+      await cancelLimitOrders(user.id)
+    }
  })

 async function handleUserUpdatedReferral(user: User, eventId: string) {
@ -117,3 +123,15 @@ async function handleUserUpdatedReferral(user: User, eventId: string) {
    )
  })
 }
+
+async function cancelLimitOrders(userId: string) {
+  const snapshot = (await firestore
+    .collectionGroup('bets')
+    .where('userId', '==', userId)
+    .where('isFilled', '==', false)
+    .get()) as QuerySnapshot<LimitBet>
+
+  await Promise.all(
+    snapshot.docs.map((doc) => doc.ref.update({ isCancelled: true }))
+  )
+}
--- a/functions/src/place-bet.ts
+++ b/functions/src/place-bet.ts
@ -11,7 +11,6 @@ import { groupBy, mapValues, sumBy, uniq } from 'lodash'
 import { APIError, newEndpoint, validate } from './api'
 import { Contract, CPMM_MIN_POOL_QTY } from '../../common/contract'
 import { User } from '../../common/user'
-import { FLAT_TRADE_FEE } from '../../common/fees'
 import {
  BetInfo,
  getBinaryCpmmBetInfo,
@ -24,7 +23,6 @@ import { floatingEqual } from '../../common/util/math'
 import { redeemShares } from './redeem-shares'
 import { log } from './utils'
 import { addUserToContractFollowers } from './follow-market'
-import { filterDefined } from '../../common/util/array'

 const bodySchema = z.object({
  contractId: z.string(),
@ -75,11 +73,9 @@ export const placebet = newEndpoint({}, async (req, auth) => {
      newTotalLiquidity,
      newP,
      makers,
-      ordersToCancel,
    } = await (async (): Promise<
      BetInfo & {
        makers?: maker[]
-        ordersToCancel?: LimitBet[]
      }
    > => {
      if (
@ -103,16 +99,17 @@ export const placebet = newEndpoint({}, async (req, auth) => {
          limitProb = Math.round(limitProb * 100) / 100
        }

-        const { unfilledBets, balanceByUserId } =
-          await getUnfilledBetsAndUserBalances(trans, contractDoc)
+        const unfilledBetsSnap = await trans.get(
+          getUnfilledBetsQuery(contractDoc)
+        )
+        const unfilledBets = unfilledBetsSnap.docs.map((doc) => doc.data())

        return getBinaryCpmmBetInfo(
          outcome,
          amount,
          contract,
          limitProb,
-          unfilledBets,
-          balanceByUserId
+          unfilledBets
        )
      } else if (
        (outcomeType == 'FREE_RESPONSE' || outcomeType === 'MULTIPLE_CHOICE') &&
@ -155,25 +152,11 @@ export const placebet = newEndpoint({}, async (req, auth) => {
    if (makers) {
      updateMakers(makers, betDoc.id, contractDoc, trans)
    }
-    if (ordersToCancel) {
-      for (const bet of ordersToCancel) {
-        trans.update(contractDoc.collection('bets').doc(bet.id), {
-          isCancelled: true,
-        })
-      }
-    }
-
-    const balanceChange =
-      newBet.amount !== 0
-        ? // quick bet
-          newBet.amount + FLAT_TRADE_FEE
-        : // limit order
-          FLAT_TRADE_FEE
-
-    trans.update(userDoc, { balance: FieldValue.increment(-balanceChange) })
-    log('Updated user balance.')

    if (newBet.amount !== 0) {
+      trans.update(userDoc, { balance: FieldValue.increment(-newBet.amount) })
+      log('Updated user balance.')
+
      trans.update(
        contractDoc,
        removeUndefinedProps({
@ -210,36 +193,13 @@ export const placebet = newEndpoint({}, async (req, auth) => {

 const firestore = admin.firestore()

-const getUnfilledBetsQuery = (contractDoc: DocumentReference) => {
+export const getUnfilledBetsQuery = (contractDoc: DocumentReference) => {
  return contractDoc
    .collection('bets')
    .where('isFilled', '==', false)
    .where('isCancelled', '==', false) as Query<LimitBet>
 }

-export const getUnfilledBetsAndUserBalances = async (
-  trans: Transaction,
-  contractDoc: DocumentReference
-) => {
-  const unfilledBetsSnap = await trans.get(getUnfilledBetsQuery(contractDoc))
-  const unfilledBets = unfilledBetsSnap.docs.map((doc) => doc.data())
-
-  // Get balance of all users with open limit orders.
-  const userIds = uniq(unfilledBets.map((bet) => bet.userId))
-  const userDocs =
-    userIds.length === 0
-      ? []
-      : await trans.getAll(
-          ...userIds.map((userId) => firestore.doc(`users/${userId}`))
-        )
-  const users = filterDefined(userDocs.map((doc) => doc.data() as User))
-  const balanceByUserId = Object.fromEntries(
-    users.map((user) => [user.id, user.balance])
-  )
-
-  return { unfilledBets, balanceByUserId }
-}
-
 type maker = {
  bet: LimitBet
  amount: number
--- a/functions/src/resolve-market.ts
+++ b/functions/src/resolve-market.ts
@ -1,6 +1,6 @@
 import * as admin from 'firebase-admin'
 import { z } from 'zod'
-import { mapValues, groupBy, sumBy, uniqBy } from 'lodash'
+import { mapValues, groupBy, sumBy } from 'lodash'

 import {
  Contract,
@ -9,20 +9,12 @@ import {
  RESOLUTIONS,
 } from '../../common/contract'
 import { Bet } from '../../common/bet'
-import {
-  getContractPath,
-  getUser,
-  getValues,
-  isProd,
-  log,
-  payUsers,
-  payUsersMultipleTransactions,
-  revalidateStaticProps,
-} from './utils'
+import { getContractPath, getUser, getValues, isProd, log, payUser, revalidateStaticProps } from './utils'
 import {
  getLoanPayouts,
  getPayouts,
  groupPayoutsByUser,
+  Payout,
 } from '../../common/payouts'
 import { isAdmin, isManifoldId } from '../../common/envs/constants'
 import { removeUndefinedProps } from '../../common/util/object'
@ -36,7 +28,6 @@ import {
  DEV_HOUSE_LIQUIDITY_PROVIDER_ID,
  HOUSE_LIQUIDITY_PROVIDER_ID,
 } from '../../common/antes'
-import { User } from 'common/user'

 const bodySchema = z.object({
  contractId: z.string(),
@ -90,10 +81,13 @@ export const resolvemarket = newEndpoint(opts, async (req, auth) => {
  if (!contractSnap.exists)
    throw new APIError(404, 'No contract exists with the provided ID')
  const contract = contractSnap.data() as Contract
-  const { creatorId } = contract
+  const { creatorId, closeTime } = contract
  const firebaseUser = await admin.auth().getUser(auth.uid)

-  const resolutionParams = getResolutionParams(contract, req.body)
+  const { value, resolutions, probabilityInt, outcome } = getResolutionParams(
+    contract,
+    req.body
+  )

  if (
    creatorId !== auth.uid &&
@ -107,16 +101,6 @@ export const resolvemarket = newEndpoint(opts, async (req, auth) => {
  const creator = await getUser(creatorId)
  if (!creator) throw new APIError(500, 'Creator not found')

-  return await resolveMarket(contract, creator, resolutionParams)
-})
-
-export const resolveMarket = async (
-  contract: Contract,
-  creator: User,
-  { value, resolutions, probabilityInt, outcome }: ResolutionParams
-) => {
-  const { creatorId, closeTime, id: contractId } = contract
-
  const resolutionProbability =
    probabilityInt !== undefined ? probabilityInt / 100 : undefined

@ -139,12 +123,8 @@ export const resolveMarket = async (
    (doc) => doc.data() as LiquidityProvision
  )

-  const {
-    payouts: traderPayouts,
-    creatorPayout,
-    liquidityPayouts,
-    collectedFees,
-  } = getPayouts(
+  const { payouts, creatorPayout, liquidityPayouts, collectedFees } =
+    getPayouts(
      outcome,
      contract,
      bets,
@ -165,50 +145,35 @@ export const resolveMarket = async (
      resolutions,
      collectedFees,
    }),
-    subsidyPool: 0,
  }

+  await contractDoc.update(updatedContract)
+
+  console.log('contract ', contractId, 'resolved to:', outcome)
+
  const openBets = bets.filter((b) => !b.isSold && !b.sale)
  const loanPayouts = getLoanPayouts(openBets)

-  const payoutsWithoutLoans = [
-    { userId: creatorId, payout: creatorPayout, deposit: creatorPayout },
-    ...liquidityPayouts.map((p) => ({ ...p, deposit: p.payout })),
-    ...traderPayouts,
-  ]
-  const payouts = [...payoutsWithoutLoans, ...loanPayouts]
-
  if (!isProd())
    console.log(
-      'trader payouts:',
-      traderPayouts,
+      'payouts:',
+      payouts,
      'creator payout:',
      creatorPayout,
-      'liquidity payout:',
-      liquidityPayouts,
-      'loan payouts:',
-      loanPayouts
+      'liquidity payout:'
    )

-  const userCount = uniqBy(payouts, 'userId').length
-  const contractDoc = firestore.doc(`contracts/${contractId}`)
+  if (creatorPayout)
+    await processPayouts([{ userId: creatorId, payout: creatorPayout }], true)

-  if (userCount <= 499) {
-    await firestore.runTransaction(async (transaction) => {
-      payUsers(transaction, payouts)
-      transaction.update(contractDoc, updatedContract)
-    })
-  } else {
-    await payUsersMultipleTransactions(payouts)
-    await contractDoc.update(updatedContract)
-  }
-
-  console.log('contract ', contractId, 'resolved to:', outcome)
+  await processPayouts(liquidityPayouts, true)

+  await processPayouts([...payouts, ...loanPayouts])
  await undoUniqueBettorRewardsIfCancelResolution(contract, outcome)
+
  await revalidateStaticProps(getContractPath(contract))

-  const userPayoutsWithoutLoans = groupPayoutsByUser(payoutsWithoutLoans)
+  const userPayoutsWithoutLoans = groupPayoutsByUser(payouts)

  const userInvestments = mapValues(
    groupBy(bets, (bet) => bet.userId),
@ -235,6 +200,18 @@ export const resolveMarket = async (
  )

  return updatedContract
+})
+
+const processPayouts = async (payouts: Payout[], isDeposit = false) => {
+  const userPayouts = groupPayoutsByUser(payouts)
+
+  const payoutPromises = Object.entries(userPayouts).map(([userId, payout]) =>
+    payUser(userId, payout, isDeposit)
+  )
+
+  return await Promise.all(payoutPromises)
+    .catch((e) => ({ status: 'error', message: e }))
+    .then(() => ({ status: 'success' }))
 }

 function getResolutionParams(contract: Contract, body: string) {
@ -301,8 +278,6 @@ function getResolutionParams(contract: Contract, body: string) {
  throw new APIError(500, `Invalid outcome type: ${outcomeType}`)
 }

-type ResolutionParams = ReturnType<typeof getResolutionParams>
-
 function validateAnswer(
  contract: FreeResponseContract | MultipleChoiceContract,
  answer: number
--- a/functions/src/scripts/add-new-notification-preference.ts
+++ b/functions/src/scripts/add-new-notification-preference.ts
@ -1,30 +0,0 @@
-import * as admin from 'firebase-admin'
-
-import { initAdmin } from './script-init'
-import { getAllPrivateUsers } from 'functions/src/utils'
-initAdmin()
-
-const firestore = admin.firestore()
-
-async function main() {
-  const privateUsers = await getAllPrivateUsers()
-  await Promise.all(
-    privateUsers.map((privateUser) => {
-      if (!privateUser.id) return Promise.resolve()
-      if (privateUser.notificationPreferences.badges_awarded === undefined) {
-        return firestore
-          .collection('private-users')
-          .doc(privateUser.id)
-          .update({
-            notificationPreferences: {
-              ...privateUser.notificationPreferences,
-              badges_awarded: ['browser'],
-            },
-          })
-      }
-      return
-    })
-  )
-}
-
-if (require.main === module) main().then(() => process.exit())
--- a/functions/src/scripts/backfill-badges.ts
+++ b/functions/src/scripts/backfill-badges.ts
@ -1,136 +0,0 @@
-import * as admin from 'firebase-admin'
-
-import { initAdmin } from './script-init'
-import { getAllUsers, getValues } from '../utils'
-import { Contract } from 'common/contract'
-import {
-  MarketCreatorBadge,
-  marketCreatorBadgeRarityThresholds,
-  StreakerBadge,
-  streakerBadgeRarityThresholds,
-} from 'common/badge'
-import { User } from 'common/user'
-initAdmin()
-
-const firestore = admin.firestore()
-
-async function main() {
-  const users = await getAllUsers()
-  // const users = filterDefined([await getUser('6hHpzvRG0pMq8PNJs7RZj2qlZGn2')]) // dev ian
-  // const users = filterDefined([await getUser('uglwf3YKOZNGjjEXKc5HampOFRE2')]) // prod David
-  // const users = filterDefined([await getUser('AJwLWoo3xue32XIiAVrL5SyR1WB2')]) // prod ian
-  await Promise.all(
-    users.map(async (user) => {
-      if (!user.id) return
-      // Only backfill users without achievements
-      if (user.achievements === undefined) {
-        await firestore.collection('users').doc(user.id).update({
-          achievements: {},
-        })
-        user.achievements = {}
-        user.achievements = await awardMarketCreatorBadges(user)
-        user.achievements = await awardBettingStreakBadges(user)
-        console.log('Added achievements to user', user.id)
-        // going to ignore backfilling the proven correct badges for now
-      } else {
-        // Make corrections to existing achievements
-        await awardMarketCreatorBadges(user)
-      }
-    })
-  )
-}
-
-if (require.main === module) main().then(() => process.exit())
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-async function removeErrorBadges(user: User) {
-  if (
-    user.achievements.streaker?.badges.some(
-      (b) => b.data.totalBettingStreak > 1
-    )
-  ) {
-    console.log(
-      `User ${
-        user.id
-      } has a streaker badge with streaks ${user.achievements.streaker?.badges.map(
-        (b) => b.data.totalBettingStreak
-      )}`
-    )
-    // delete non 1,50 streaks
-    user.achievements.streaker.badges =
-      user.achievements.streaker.badges.filter((b) =>
-        streakerBadgeRarityThresholds.includes(b.data.totalBettingStreak)
-      )
-    // update user
-    await firestore.collection('users').doc(user.id).update({
-      achievements: user.achievements,
-    })
-  }
-}
-
-async function awardMarketCreatorBadges(user: User) {
-  // Award market maker badges
-  const contracts = (
-    await getValues<Contract>(
-      firestore.collection(`contracts`).where('creatorId', '==', user.id)
-    )
-  ).filter((c) => !c.resolution || c.resolution != 'CANCEL')
-
-  const achievements = {
-    ...user.achievements,
-    marketCreator: {
-      badges: [...(user.achievements.marketCreator?.badges ?? [])],
-    },
-  }
-  for (const threshold of marketCreatorBadgeRarityThresholds) {
-    const alreadyHasBadge = user.achievements.marketCreator?.badges.some(
-      (b) => b.data.totalContractsCreated === threshold
-    )
-    if (alreadyHasBadge) continue
-    if (contracts.length >= threshold) {
-      console.log(`User ${user.id} has at least ${threshold} contracts`)
-      const badge = {
-        type: 'MARKET_CREATOR',
-        name: 'Market Creator',
-        data: {
-          totalContractsCreated: threshold,
-        },
-        createdTime: Date.now(),
-      } as MarketCreatorBadge
-      achievements.marketCreator.badges.push(badge)
-    }
-  }
-  // update user
-  await firestore.collection('users').doc(user.id).update({
-    achievements,
-  })
-  return achievements
-}
-
-async function awardBettingStreakBadges(user: User) {
-  const streak = user.currentBettingStreak ?? 0
-  const achievements = {
-    ...user.achievements,
-    streaker: {
-      badges: [...(user.achievements?.streaker?.badges ?? [])],
-    },
-  }
-  for (const threshold of streakerBadgeRarityThresholds) {
-    if (streak >= threshold) {
-      const badge = {
-        type: 'STREAKER',
-        name: 'Streaker',
-        data: {
-          totalBettingStreak: threshold,
-        },
-        createdTime: Date.now(),
-      } as StreakerBadge
-      achievements.streaker.badges.push(badge)
-    }
-  }
-  // update user
-  await firestore.collection('users').doc(user.id).update({
-    achievements,
-  })
-  return achievements
-}
--- a/functions/src/scripts/backfill-subsidy-pool.ts
+++ b/functions/src/scripts/backfill-subsidy-pool.ts
@ -1,24 +0,0 @@
-import * as admin from 'firebase-admin'
-import { initAdmin } from './script-init'
-
-initAdmin()
-const firestore = admin.firestore()
-
-if (require.main === module) {
-  const contractsRef = firestore.collection('contracts')
-  contractsRef.get().then(async (contractsSnaps) => {
-
-    console.log(`Loaded ${contractsSnaps.size} contracts.`)
-
-    const needsFilling = contractsSnaps.docs.filter((ct) => {
-      return !('subsidyPool' in ct.data())
-    })
-
-    console.log(`Found ${needsFilling.length} contracts to update.`)
-    await Promise.all(
-      needsFilling.map((ct) => ct.ref.update({ subsidyPool: 0 }))
-    )
-
-    console.log(`Updated all contracts.`)
-  })
-}
--- a/functions/src/scripts/contest/bulk-add-liquidity.ts
+++ b/functions/src/scripts/contest/bulk-add-liquidity.ts
@ -1,54 +0,0 @@
-// Run with `npx ts-node src/scripts/contest/resolve-markets.ts`
-
-const DOMAIN = 'http://localhost:3000'
-// Dev API key for Cause Exploration Prizes (@CEP)
-// const API_KEY = '188f014c-0ba2-4c35-9e6d-88252e281dbf'
-// DEV API key for Criticism and Red Teaming (@CARTBot)
-const API_KEY = '6ff1f78a-32fe-43b2-b31b-9e3c78c5f18c'
-
-// Warning: Checking these in can be dangerous!
-// Prod API key for @CEPBot
-
-// Can just curl /v0/group/{slug} to get a group
-async function getGroupBySlug(slug: string) {
-  const resp = await fetch(`${DOMAIN}/api/v0/group/${slug}`)
-  return await resp.json()
-}
-
-async function getMarketsByGroupId(id: string) {
-  // API structure: /v0/group/by-id/[id]/markets
-  const resp = await fetch(`${DOMAIN}/api/v0/group/by-id/${id}/markets`)
-  return await resp.json()
-}
-
-async function addLiquidityById(id: string, amount: number) {
-  const resp = await fetch(`${DOMAIN}/api/v0/market/${id}/add-liquidity`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Key ${API_KEY}`,
-    },
-    body: JSON.stringify({
-      amount: amount,
-    }),
-  })
-  return await resp.json()
-}
-
-async function main() {
-  const group = await getGroupBySlug('cart-contest')
-  const markets = await getMarketsByGroupId(group.id)
-
-  // Count up some metrics
-  console.log('Number of markets', markets.length)
-
-  // Resolve each market to NO
-  for (const market of markets.slice(0, 3)) {
-    console.log(market.slug, market.totalLiquidity)
-    const resp = await addLiquidityById(market.id, 200)
-    console.log(resp)
-  }
-}
-main()
-
-export {}
--- a/functions/src/scripts/contest/bulk-resolve-markets.ts
+++ b/functions/src/scripts/contest/bulk-resolve-markets.ts
@ -1,65 +0,0 @@
-// Run with `npx ts-node src/scripts/contest/resolve-markets.ts`
-
-const DOMAIN = 'dev.manifold.markets'
-// Dev API key for Cause Exploration Prizes (@CEP)
-const API_KEY = '188f014c-0ba2-4c35-9e6d-88252e281dbf'
-const GROUP_SLUG = 'cart-contest'
-
-// Can just curl /v0/group/{slug} to get a group
-async function getGroupBySlug(slug: string) {
-  const resp = await fetch(`https://${DOMAIN}/api/v0/group/${slug}`)
-  return await resp.json()
-}
-
-async function getMarketsByGroupId(id: string) {
-  // API structure: /v0/group/by-id/[id]/markets
-  const resp = await fetch(`https://${DOMAIN}/api/v0/group/by-id/${id}/markets`)
-  return await resp.json()
-}
-
-/* Example curl request:
-# Resolve a binary market
-$ curl https://manifold.markets/api/v0/market/{marketId}/resolve -X POST \
-    -H 'Content-Type: application/json' \
-    -H 'Authorization: Key {...}' \
-    --data-raw '{"outcome": "YES"}'
-*/
-async function resolveMarketById(
-  id: string,
-  outcome: 'YES' | 'NO' | 'MKT' | 'CANCEL'
-) {
-  const resp = await fetch(`https://${DOMAIN}/api/v0/market/${id}/resolve`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Key ${API_KEY}`,
-    },
-    body: JSON.stringify({
-      outcome,
-    }),
-  })
-  return await resp.json()
-}
-
-async function main() {
-  const group = await getGroupBySlug(GROUP_SLUG)
-  const markets = await getMarketsByGroupId(group.id)
-
-  // Count up some metrics
-  console.log('Number of markets', markets.length)
-  console.log(
-    'Number of resolved markets',
-    markets.filter((m: any) => m.isResolved).length
-  )
-
-  // Resolve each market to NO
-  for (const market of markets) {
-    if (!market.isResolved) {
-      console.log(`Resolving market ${market.url} to NO`)
-      await resolveMarketById(market.id, 'NO')
-    }
-  }
-}
-main()
-
-export {}
--- a/functions/src/scripts/contest/bulk-create-markets.ts
+++ b/functions/src/scripts/contest/bulk-create-markets.ts
--- a/functions/src/scripts/convert-tag-to-group.ts
+++ b/functions/src/scripts/convert-tag-to-group.ts
@ -42,7 +42,6 @@ const createGroup = async (
    totalContracts: contracts.length,
    totalMembers: 1,
    postIds: [],
-    pinnedItems: [],
  }
  await groupRef.create(group)
  // create a GroupMemberDoc for the creator
--- a/functions/src/scripts/denormalize.ts
+++ b/functions/src/scripts/denormalize.ts
@ -3,6 +3,7 @@

 import { DocumentSnapshot, Transaction } from 'firebase-admin/firestore'
 import { isEqual, zip } from 'lodash'
+import { UpdateSpec } from '../utils'

 export type DocumentValue = {
  doc: DocumentSnapshot
@ -53,7 +54,7 @@ export function getDiffUpdate(diff: DocumentDiff) {
  return {
    doc: diff.dest.doc.ref,
    fields: Object.fromEntries(zip(diff.dest.fields, diff.src.vals)),
-  }
+  } as UpdateSpec
 }

 export function applyDiff(transaction: Transaction, diff: DocumentDiff) {
--- a/functions/src/scripts/drizzle.ts
+++ b/functions/src/scripts/drizzle.ts
@ -1,8 +0,0 @@
-import { initAdmin } from './script-init'
-initAdmin()
-
-import { drizzleLiquidity } from '../drizzle-liquidity'
-
-if (require.main === module) {
-  drizzleLiquidity().then(() => process.exit())
-}
--- a/functions/src/scripts/resolve-markets-again.ts
+++ b/functions/src/scripts/resolve-markets-again.ts
@ -1,59 +0,0 @@
-import { initAdmin } from './script-init'
-initAdmin()
-
-import { zip } from 'lodash'
-import { filterDefined } from 'common/util/array'
-import { resolveMarket } from '../resolve-market'
-import { getContract, getUser } from '../utils'
-
-if (require.main === module) {
-  const contractIds = process.argv.slice(2)
-  if (contractIds.length === 0) {
-    throw new Error('No contract ids provided')
-  }
-  resolveMarketsAgain(contractIds).then(() => process.exit(0))
-}
-
-async function resolveMarketsAgain(contractIds: string[]) {
-  const maybeContracts = await Promise.all(contractIds.map(getContract))
-  if (maybeContracts.some((c) => !c)) {
-    throw new Error('Invalid contract id')
-  }
-  const contracts = filterDefined(maybeContracts)
-
-  const maybeCreators = await Promise.all(
-    contracts.map((c) => getUser(c.creatorId))
-  )
-  if (maybeCreators.some((c) => !c)) {
-    throw new Error('No creator found')
-  }
-  const creators = filterDefined(maybeCreators)
-
-  if (
-    !contracts.every((c) => c.resolution === 'YES' || c.resolution === 'NO')
-  ) {
-    throw new Error('Only YES or NO resolutions supported')
-  }
-
-  const resolutionParams = contracts.map((c) => ({
-    outcome: c.resolution as string,
-    value: undefined,
-    probabilityInt: undefined,
-    resolutions: undefined,
-  }))
-
-  const params = zip(contracts, creators, resolutionParams)
-
-  for (const [contract, creator, resolutionParams] of params) {
-    if (contract && creator && resolutionParams) {
-      console.log('Resolving', contract.question)
-      try {
-        await resolveMarket(contract, creator, resolutionParams)
-      } catch (e) {
-        console.log(e)
-      }
-    }
-  }
-
-  console.log(`Resolved all contracts.`)
-}
--- a/functions/src/scripts/update-contract-tags.ts
+++ b/functions/src/scripts/update-contract-tags.ts
@ -0,0 +1,46 @@
+import * as admin from 'firebase-admin'
+import { uniq } from 'lodash'
+
+import { initAdmin } from './script-init'
+initAdmin()
+
+import { Contract } from '../../../common/contract'
+import { parseTags } from '../../../common/util/parse'
+import { getValues } from '../utils'
+
+async function updateContractTags() {
+  const firestore = admin.firestore()
+  console.log('Updating contracts tags')
+
+  const contracts = await getValues<Contract>(firestore.collection('contracts'))
+
+  console.log('Loaded', contracts.length, 'contracts')
+
+  for (const contract of contracts) {
+    const contractRef = firestore.doc(`contracts/${contract.id}`)
+
+    const tags = uniq([
+      ...parseTags(contract.question + contract.description),
+      ...(contract.tags ?? []),
+    ])
+    const lowercaseTags = tags.map((tag) => tag.toLowerCase())
+
+    console.log(
+      'Updating tags',
+      contract.slug,
+      'from',
+      contract.tags,
+      'to',
+      tags
+    )
+
+    await contractRef.update({
+      tags,
+      lowercaseTags,
+    } as Partial<Contract>)
+  }
+}
+
+if (require.main === module) {
+  updateContractTags().then(() => process.exit())
+}
--- a/functions/src/scripts/update-groups.ts
+++ b/functions/src/scripts/update-groups.ts
@ -89,20 +89,17 @@ const getGroups = async () => {
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 async function updateTotalContractsAndMembers() {
  const groups = await getGroups()
-  await Promise.all(
-    groups.map(async (group) => {
+  for (const group of groups) {
    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() {
@ -120,6 +117,6 @@ async function removeUnusedMemberAndContractFields() {
 if (require.main === module) {
  initAdmin()
  // convertGroupFieldsToGroupDocuments()
-  updateTotalContractsAndMembers()
-  // removeUnusedMemberAndContractFields()
+  // updateTotalContractsAndMembers()
+  removeUnusedMemberAndContractFields()
 }
--- a/functions/src/sell-shares.ts
+++ b/functions/src/sell-shares.ts
@ -1,7 +1,6 @@
 import { mapValues, groupBy, sumBy, uniq } from 'lodash'
 import * as admin from 'firebase-admin'
 import { z } from 'zod'
-import { FieldValue } from 'firebase-admin/firestore'

 import { APIError, newEndpoint, validate } from './api'
 import { Contract, CPMM_MIN_POOL_QTY } from '../../common/contract'
@ -11,7 +10,8 @@ import { addObjects, removeUndefinedProps } from '../../common/util/object'
 import { log } from './utils'
 import { Bet } from '../../common/bet'
 import { floatingEqual, floatingLesserEqual } from '../../common/util/math'
-import { getUnfilledBetsAndUserBalances, updateMakers } from './place-bet'
+import { getUnfilledBetsQuery, updateMakers } from './place-bet'
+import { FieldValue } from 'firebase-admin/firestore'
 import { redeemShares } from './redeem-shares'
 import { removeUserFromContractFollowers } from './follow-market'

@ -29,18 +29,16 @@ export const sellshares = newEndpoint({}, async (req, auth) => {
    const contractDoc = firestore.doc(`contracts/${contractId}`)
    const userDoc = firestore.doc(`users/${auth.uid}`)
    const betsQ = contractDoc.collection('bets').where('userId', '==', auth.uid)
-    const [
-      [contractSnap, userSnap],
-      userBetsSnap,
-      { unfilledBets, balanceByUserId },
-    ] = await Promise.all([
+    const [[contractSnap, userSnap], userBetsSnap, unfilledBetsSnap] =
+      await Promise.all([
        transaction.getAll(contractDoc, userDoc),
        transaction.get(betsQ),
-      getUnfilledBetsAndUserBalances(transaction, contractDoc),
+        transaction.get(getUnfilledBetsQuery(contractDoc)),
      ])
    if (!contractSnap.exists) throw new APIError(400, 'Contract not found.')
    if (!userSnap.exists) throw new APIError(400, 'User not found.')
    const userBets = userBetsSnap.docs.map((doc) => doc.data() as Bet)
+    const unfilledBets = unfilledBetsSnap.docs.map((doc) => doc.data())

    const contract = contractSnap.data() as Contract
    const user = userSnap.data() as User
@ -88,13 +86,11 @@ export const sellshares = newEndpoint({}, async (req, auth) => {
    let loanPaid = saleFrac * loanAmount
    if (!isFinite(loanPaid)) loanPaid = 0

-    const { newBet, newPool, newP, fees, makers, ordersToCancel } =
-      getCpmmSellBetInfo(
+    const { newBet, newPool, newP, fees, makers } = getCpmmSellBetInfo(
      soldShares,
      chosenOutcome,
      contract,
      unfilledBets,
-        balanceByUserId,
      loanPaid
    )

@ -131,12 +127,6 @@ export const sellshares = newEndpoint({}, async (req, auth) => {
      })
    )

-    for (const bet of ordersToCancel) {
-      transaction.update(contractDoc.collection('bets').doc(bet.id), {
-        isCancelled: true,
-      })
-    }
-
    return { newBet, makers, maxShares, soldShares }
  })

--- a/functions/src/serve.ts
+++ b/functions/src/serve.ts
@ -19,7 +19,8 @@ import { sellbet } from './sell-bet'
 import { sellshares } from './sell-shares'
 import { claimmanalink } from './claim-manalink'
 import { createmarket } from './create-market'
-import { createcomment } from './create-comment'
+import { addliquidity } from './add-liquidity'
+import { withdrawliquidity } from './withdraw-liquidity'
 import { creategroup } from './create-group'
 import { resolvemarket } from './resolve-market'
 import { unsubscribe } from './unsubscribe'
@ -28,7 +29,6 @@ import { getcurrentuser } from './get-current-user'
 import { createpost } from './create-post'
 import { savetwitchcredentials } from './save-twitch-credentials'
 import { testscheduledfunction } from './test-scheduled-function'
-import { addcommentbounty, awardcommentbounty } from './update-comment-bounty'

 type Middleware = (req: Request, res: Response, next: NextFunction) => void
 const app = express()
@ -54,15 +54,14 @@ addJsonEndpointRoute('/transact', transact)
 addJsonEndpointRoute('/changeuserinfo', changeuserinfo)
 addJsonEndpointRoute('/createuser', createuser)
 addJsonEndpointRoute('/createanswer', createanswer)
-addJsonEndpointRoute('/createcomment', createcomment)
 addJsonEndpointRoute('/placebet', placebet)
 addJsonEndpointRoute('/cancelbet', cancelbet)
 addJsonEndpointRoute('/sellbet', sellbet)
 addJsonEndpointRoute('/sellshares', sellshares)
 addJsonEndpointRoute('/claimmanalink', claimmanalink)
 addJsonEndpointRoute('/createmarket', createmarket)
-addJsonEndpointRoute('/addCommentBounty', addcommentbounty)
-addJsonEndpointRoute('/awardCommentBounty', awardcommentbounty)
+addJsonEndpointRoute('/addliquidity', addliquidity)
+addJsonEndpointRoute('/withdrawliquidity', withdrawliquidity)
 addJsonEndpointRoute('/creategroup', creategroup)
 addJsonEndpointRoute('/resolvemarket', resolvemarket)
 addJsonEndpointRoute('/unsubscribe', unsubscribe)
--- a/functions/src/test-scheduled-function.ts
+++ b/functions/src/test-scheduled-function.ts
@ -1,6 +1,6 @@
 import { APIError, newEndpoint } from './api'
+import { sendPortfolioUpdateEmailsToAllUsers } from './weekly-portfolio-emails'
 import { isProd } from './utils'
-import { sendMarketCloseEmails } from 'functions/src/market-close-notifications'

 // Function for testing scheduled functions locally
 export const testscheduledfunction = newEndpoint(
@ -10,7 +10,7 @@ export const testscheduledfunction = newEndpoint(
      throw new APIError(400, 'This function is only available in dev mode')

    // Replace your function here
-    await sendMarketCloseEmails()
+    await sendPortfolioUpdateEmailsToAllUsers()

    return { success: true }
  }
--- a/functions/src/unsubscribe.ts
+++ b/functions/src/unsubscribe.ts
@ -4,7 +4,6 @@ import { getPrivateUser } from './utils'
 import { PrivateUser } from '../../common/user'
 import { NOTIFICATION_DESCRIPTIONS } from '../../common/notification'
 import { notification_preference } from '../../common/user-notification-preferences'
-import { getFunctionUrl } from '../../common/api'

 export const unsubscribe: EndpointDefinition = {
  opts: { method: 'GET', minInstances: 1 },
@ -21,8 +20,6 @@ export const unsubscribe: EndpointDefinition = {
      res.status(400).send('Invalid subscription type parameter.')
      return
    }
-    const optOutAllType: notification_preference = 'opt_out_all'
-    const wantsToOptOutAll = notificationSubscriptionType === optOutAllType

    const user = await getPrivateUser(id)

@ -34,181 +31,20 @@ export const unsubscribe: EndpointDefinition = {
    const previousDestinations =
      user.notificationPreferences[notificationSubscriptionType]

-    let newDestinations = previousDestinations
-    if (wantsToOptOutAll) newDestinations.push('email')
-    else
-      newDestinations = previousDestinations.filter(
-        (destination) => destination !== 'email'
-      )
-
    console.log(previousDestinations)
    const { email } = user

    const update: Partial<PrivateUser> = {
      notificationPreferences: {
        ...user.notificationPreferences,
-        [notificationSubscriptionType]: newDestinations,
+        [notificationSubscriptionType]: previousDestinations.filter(
+          (destination) => destination !== 'email'
+        ),
      },
    }

    await firestore.collection('private-users').doc(id).update(update)
-    const unsubscribeEndpoint = getFunctionUrl('unsubscribe')

-    const optOutAllUrl = `${unsubscribeEndpoint}?id=${id}&type=${optOutAllType}`
-    if (wantsToOptOutAll) {
-      res.send(
-        `
-     <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xmlns:v="urn:schemas-microsoft-com:vml"
-      xmlns:o="urn:schemas-microsoft-com:office:office">
-
-<head>
-  <title>Unsubscribe from Manifold Markets emails</title>
-  <!--[if !mso]><!-->
-  <meta http-equiv="X-UA-Compatible" content="IE=edge">
-  <!--<![endif]-->
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-  <meta name="viewport" content="width=device-width,initial-scale=1">
-  <style type="text/css">
-      #outlook a {
-          padding: 0;
-      }
-
-      body {
-          margin: 0;
-          padding: 0;
-          -webkit-text-size-adjust: 100%;
-          -ms-text-size-adjust: 100%;
-      }
-
-      table,
-      td {
-          border-collapse: collapse;
-          mso-table-lspace: 0pt;
-          mso-table-rspace: 0pt;
-      }
-
-      img {
-          border: 0;
-          height: auto;
-          line-height: 100%;
-          outline: none;
-          text-decoration: none;
-          -ms-interpolation-mode: bicubic;
-      }
-
-      p {
-          display: block;
-          margin: 13px 0;
-      }
-  </style>
-  <!--[if mso]>
-  <noscript>
-    <xml>
-      <o:OfficeDocumentSettings>
-        <o:AllowPNG/>
-        <o:PixelsPerInch>96</o:PixelsPerInch>
-      </o:OfficeDocumentSettings>
-    </xml>
-  </noscript>
-  <![endif]-->
-  <!--[if lte mso 11]>
-  <style type="text/css">
-    .mj-outlook-group-fix { width:100% !important; }
-  </style>
-  <![endif]-->
-  <style type="text/css">
-      @media only screen and (min-width:480px) {
-          .mj-column-per-100 {
-              width: 100% !important;
-              max-width: 100%;
-          }
-      }
-  </style>
-  <style media="screen and (min-width:480px)">
-      .moz-text-html .mj-column-per-100 {
-          width: 100% !important;
-          max-width: 100%;
-      }
-  </style>
-  <style type="text/css">
-      [owa] .mj-column-per-100 {
-          width: 100% !important;
-          max-width: 100%;
-      }
-  </style>
-  <style type="text/css">
-      @media only screen and (max-width:480px) {
-          table.mj-full-width-mobile {
-              width: 100% !important;
-          }
-
-          td.mj-full-width-mobile {
-              width: auto !important;
-          }
-      }
-  </style>
-</head>
-<body style="word-spacing:normal;background-color:#F4F4F4;">
-<div style="background-color:#F4F4F4;">
-  <!--[if mso | IE]><table align="center" border="0" cellpadding="0" cellspacing="0" class="" role="presentation" style="width:600px;" width="600" bgcolor="#ffffff" ><tr><td style="line-height:0px;font-size:0px;mso-line-height-rule:exactly;"><![endif]-->
-  <div style="background:#ffffff;background-color:#ffffff;margin:0px auto;max-width:600px;">
-    <table align="center" border="0" cellpadding="0" cellspacing="0" role="presentation"
-           style="background:#ffffff;background-color:#ffffff;width:100%;">
-      <tbody>
-      <tr>
-        <td
-          style="direction:ltr;font-size:0px;padding:0px 0px 0px 0px;padding-bottom:0px;padding-left:0px;padding-right:0px;padding-top:0px;text-align:center;">
-          <!--[if mso | IE]><table role="presentation" border="0" cellpadding="0" cellspacing="0"><tr><td class="" style="vertical-align:top;width:600px;" ><![endif]-->
-          <div class="mj-column-per-100 mj-outlook-group-fix"
-               style="font-size:0px;text-align:left;direction:ltr;display:inline-block;vertical-align:top;width:100%;">
-            <table border="0" cellpadding="0" cellspacing="0" role="presentation" style="vertical-align:top;"
-                   width="100%">
-              <tbody>
-              <tr>
-                <td style="width:550px;">
-                  <a href="https://manifold.markets" target="_blank">
-                    <img alt="banner logo" height="auto" src="https://manifold.markets/logo-banner.png"
-                         style="border:none;display:block;outline:none;text-decoration:none;height:auto;width:100%;font-size:13px;"
-                         title="" width="550">
-                  </a>
-                </td>
-              </tr>
-              <tr>
-                <td align="left"
-                    style="font-size:0px;padding:10px 25px;padding-top:0px;padding-bottom:0px;word-break:break-word;">
-                  <div
-                    style="font-family:Arial, sans-serif;font-size:18px;letter-spacing:normal;line-height:1;text-align:left;color:#000000;">
-                    <p class="text-build-content"
-                       style="line-height: 24px; margin: 10px 0; margin-top: 10px; margin-bottom: 10px;"
-                       data-testid="4XoHRGw1Y">
-                       <span
-                         style="color:#000000;font-family:Arial, Helvetica, sans-serif;font-size:18px;">
-                      ${email} has opted out of receiving unnecessary email notifications
-                    </span>
-
-                  </div>
-
-                </td>
-              </tr>
-              <tr>
-                <td>
-                  <p></p>
-                </td>
-              </tr>
-              </tbody>
-            </table>
-          </div>
-        </td>
-      </tr>
-      </tbody>
-    </table>
-  </div>
-</div>
-</body>
-</html>`
-      )
-    } else {
    res.send(
      `
 <!DOCTYPE html>
@ -216,7 +52,7 @@ export const unsubscribe: EndpointDefinition = {
      xmlns:o="urn:schemas-microsoft-com:office:office">

 <head>
-  <title>Unsubscribe from Manifold Markets emails</title>
+  <title>Manifold Markets 7th Day Anniversary Gift!</title>
  <!--[if !mso]><!-->
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <!--<![endif]-->
@ -361,12 +197,6 @@ export const unsubscribe: EndpointDefinition = {
                    <br/>
                    <br/>
                    <span>Click
-                    <a href=${optOutAllUrl}>here</a>
-                       to unsubscribe from all unnecessary emails.
-                      </span>
-                                        <br/>
-                                        <br/>
-                    <span>Click
                    <a href='https://manifold.markets/notifications?tab=settings'>here</a>
                       to manage the rest of your notification settings.
                      </span>
@ -392,7 +222,6 @@ export const unsubscribe: EndpointDefinition = {
 </html>
 `
    )
-    }
  },
 }

--- a/functions/src/update-comment-bounty.ts
+++ b/functions/src/update-comment-bounty.ts
@ -1,162 +0,0 @@
-import * as admin from 'firebase-admin'
-import { z } from 'zod'
-
-import { Contract } from '../../common/contract'
-import { User } from '../../common/user'
-import { removeUndefinedProps } from '../../common/util/object'
-import { APIError, newEndpoint, validate } from './api'
-import {
-  DEV_HOUSE_LIQUIDITY_PROVIDER_ID,
-  HOUSE_LIQUIDITY_PROVIDER_ID,
-} from '../../common/antes'
-import { isProd } from './utils'
-import {
-  CommentBountyDepositTxn,
-  CommentBountyWithdrawalTxn,
-} from '../../common/txn'
-import { runTxn } from './transact'
-import { Comment } from '../../common/comment'
-import { createBountyNotification } from './create-notification'
-
-const bodySchema = z.object({
-  contractId: z.string(),
-  amount: z.number().gt(0),
-})
-const awardBodySchema = z.object({
-  contractId: z.string(),
-  commentId: z.string(),
-  amount: z.number().gt(0),
-})
-
-export const addcommentbounty = newEndpoint({}, async (req, auth) => {
-  const { amount, contractId } = validate(bodySchema, req.body)
-
-  if (!isFinite(amount)) throw new APIError(400, 'Invalid amount')
-
-  // run as transaction to prevent race conditions
-  return await firestore.runTransaction(async (transaction) => {
-    const userDoc = firestore.doc(`users/${auth.uid}`)
-    const userSnap = await transaction.get(userDoc)
-    if (!userSnap.exists) throw new APIError(400, 'User not found')
-    const user = userSnap.data() as User
-
-    const contractDoc = firestore.doc(`contracts/${contractId}`)
-    const contractSnap = await transaction.get(contractDoc)
-    if (!contractSnap.exists) throw new APIError(400, 'Invalid contract')
-    const contract = contractSnap.data() as Contract
-
-    if (user.balance < amount)
-      throw new APIError(400, 'Insufficient user balance')
-
-    const newCommentBountyTxn = {
-      fromId: user.id,
-      fromType: 'USER',
-      toId: isProd()
-        ? HOUSE_LIQUIDITY_PROVIDER_ID
-        : DEV_HOUSE_LIQUIDITY_PROVIDER_ID,
-      toType: 'BANK',
-      amount,
-      token: 'M$',
-      category: 'COMMENT_BOUNTY',
-      data: {
-        contractId,
-      },
-      description: `Deposit M$${amount} from ${user.id} for comment bounty for contract ${contractId}`,
-    } as CommentBountyDepositTxn
-
-    const result = await runTxn(transaction, newCommentBountyTxn)
-
-    transaction.update(
-      contractDoc,
-      removeUndefinedProps({
-        openCommentBounties: (contract.openCommentBounties ?? 0) + amount,
-      })
-    )
-
-    return result
-  })
-})
-export const awardcommentbounty = newEndpoint({}, async (req, auth) => {
-  const { amount, commentId, contractId } = validate(awardBodySchema, req.body)
-
-  if (!isFinite(amount)) throw new APIError(400, 'Invalid amount')
-
-  // run as transaction to prevent race conditions
-  const res = await firestore.runTransaction(async (transaction) => {
-    const userDoc = firestore.doc(`users/${auth.uid}`)
-    const userSnap = await transaction.get(userDoc)
-    if (!userSnap.exists) throw new APIError(400, 'User not found')
-    const user = userSnap.data() as User
-
-    const contractDoc = firestore.doc(`contracts/${contractId}`)
-    const contractSnap = await transaction.get(contractDoc)
-    if (!contractSnap.exists) throw new APIError(400, 'Invalid contract')
-    const contract = contractSnap.data() as Contract
-
-    if (user.id !== contract.creatorId)
-      throw new APIError(
-        400,
-        'Only contract creator can award comment bounties'
-      )
-
-    const commentDoc = firestore.doc(
-      `contracts/${contractId}/comments/${commentId}`
-    )
-    const commentSnap = await transaction.get(commentDoc)
-    if (!commentSnap.exists) throw new APIError(400, 'Invalid comment')
-
-    const comment = commentSnap.data() as Comment
-    const amountAvailable = contract.openCommentBounties ?? 0
-    if (amountAvailable < amount)
-      throw new APIError(400, 'Insufficient open bounty balance')
-
-    const newCommentBountyTxn = {
-      fromId: isProd()
-        ? HOUSE_LIQUIDITY_PROVIDER_ID
-        : DEV_HOUSE_LIQUIDITY_PROVIDER_ID,
-      fromType: 'BANK',
-      toId: comment.userId,
-      toType: 'USER',
-      amount,
-      token: 'M$',
-      category: 'COMMENT_BOUNTY',
-      data: {
-        contractId,
-        commentId,
-      },
-      description: `Withdrawal M$${amount} from BANK for comment ${comment.id} bounty for contract ${contractId}`,
-    } as CommentBountyWithdrawalTxn
-
-    const result = await runTxn(transaction, newCommentBountyTxn)
-
-    await transaction.update(
-      contractDoc,
-      removeUndefinedProps({
-        openCommentBounties: amountAvailable - amount,
-      })
-    )
-    await transaction.update(
-      commentDoc,
-      removeUndefinedProps({
-        bountiesAwarded: (comment.bountiesAwarded ?? 0) + amount,
-      })
-    )
-
-    return { ...result, comment, contract, user }
-  })
-  if (res.txn?.id) {
-    const { comment, contract, user } = res
-    await createBountyNotification(
-      user,
-      comment.userId,
-      amount,
-      res.txn.id,
-      contract,
-      comment.id
-    )
-  }
-
-  return res
-})
-
-const firestore = admin.firestore()
--- a/functions/src/update-metrics.ts
+++ b/functions/src/update-metrics.ts
@ -1,11 +1,10 @@
 import * as functions from 'firebase-functions'
 import * as admin from 'firebase-admin'
-import { groupBy, keyBy, sortBy } from 'lodash'
-import fetch from 'node-fetch'
-
+import { groupBy, isEmpty, keyBy, last, sortBy } from 'lodash'
 import { getValues, log, logMemory, writeAsync } from './utils'
 import { Bet } from '../../common/bet'
 import { Contract, CPMM } from '../../common/contract'
+
 import { PortfolioMetrics, User } from '../../common/user'
 import { DAY_MS } from '../../common/util/time'
 import { getLoanUpdates } from '../../common/loans'
@ -15,82 +14,41 @@ import {
  calculateNewPortfolioMetrics,
  calculateNewProfit,
  calculateProbChanges,
-  calculateMetricsByContract,
-  computeElasticity,
  computeVolume,
 } from '../../common/calculate-metrics'
 import { getProbability } from '../../common/calculate'
-import { Group } from '../../common/group'
-import { batchedWaitAll } from '../../common/util/promise'
-import { newEndpointNoAuth } from './api'
-import { getFunctionUrl } from '../../common/api'
-import { filterDefined } from '../../common/util/array'
+import { Group } from 'common/group'

 const firestore = admin.firestore()
-export const scheduleUpdateMetrics = functions.pubsub
-  .schedule('every 15 minutes')
-  .onRun(async () => {
-    const url = getFunctionUrl('updatemetrics')
-    console.log('Scheduling update metrics', url)
-    const response = await fetch(url, {
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      method: 'POST',
-      body: JSON.stringify({}),
-    })

-    const json = await response.json()
-
-    if (response.ok) console.log(json)
-    else console.error(json)
-  })
-
-export const updatemetrics = newEndpointNoAuth(
-  { timeoutSeconds: 2000, memory: '8GiB', minInstances: 0 },
-  async (_req) => {
-    await updateMetricsCore()
-    return { success: true }
-  }
-)
+export const updateMetrics = functions
+  .runWith({ memory: '8GB', timeoutSeconds: 540 })
+  .pubsub.schedule('every 15 minutes')
+  .onRun(updateMetricsCore)

 export async function updateMetricsCore() {
-  console.log('Loading users')
-  const users = await getValues<User>(firestore.collection('users'))
-
-  console.log('Loading contracts')
-  const contracts = await getValues<Contract>(firestore.collection('contracts'))
-
-  console.log('Loading portfolio history')
-  const userPortfolioHistory = await loadPortfolioHistory(users)
-
-  console.log('Loading groups')
-  const groups = await getValues<Group>(firestore.collection('groups'))
-
-  console.log('Loading bets')
-  const contractBets = await batchedWaitAll(
-    contracts
-      .filter((c) => c.id)
-      .map(
-        (c) => () =>
-          getValues<Bet>(
-            firestore.collection('contracts').doc(c.id).collection('bets')
-          )
+  const [users, contracts, bets, allPortfolioHistories, groups] =
+    await Promise.all([
+      getValues<User>(firestore.collection('users')),
+      getValues<Contract>(firestore.collection('contracts')),
+      getValues<Bet>(firestore.collectionGroup('bets')),
+      getValues<PortfolioMetrics>(
+        firestore
+          .collectionGroup('portfolioHistory')
+          .where('timestamp', '>', Date.now() - 31 * DAY_MS) // so it includes just over a month ago
      ),
-    100
-  )
-  const bets = contractBets.flat()
+      getValues<Group>(firestore.collection('groups')),
+    ])

-  console.log('Loading group contracts')
  const contractsByGroup = await Promise.all(
-    groups.map((group) =>
-      getValues(
+    groups.map((group) => {
+      return getValues(
        firestore
          .collection('groups')
          .doc(group.id)
          .collection('groupContracts')
      )
-    )
+    })
  )
  log(
    `Loaded ${users.length} users, ${contracts.length} contracts, and ${bets.length} bets.`
@ -126,7 +84,6 @@ export async function updateMetricsCore() {
        fields: {
          volume24Hours: computeVolume(contractBets, now - DAY_MS),
          volume7Days: computeVolume(contractBets, now - DAY_MS * 7),
-          elasticity: computeElasticity(contractBets, contract),
          ...cpmmFields,
        },
      }
@ -139,10 +96,11 @@ export async function updateMetricsCore() {
  )
  const contractsByUser = groupBy(contracts, (contract) => contract.creatorId)
  const betsByUser = groupBy(bets, (bet) => bet.userId)
+  const portfolioHistoryByUser = groupBy(allPortfolioHistories, (p) => p.userId)

  const userMetrics = users.map((user) => {
    const currentBets = betsByUser[user.id] ?? []
-    const portfolioHistory = userPortfolioHistory[user.id] ?? []
+    const portfolioHistory = portfolioHistoryByUser[user.id] ?? []
    const userContracts = contractsByUser[user.id] ?? []
    const newCreatorVolume = calculateCreatorVolume(userContracts)
    const newPortfolio = calculateNewPortfolioMetrics(
@ -150,51 +108,21 @@ export async function updateMetricsCore() {
      contractsById,
      currentBets
    )
-    const currPortfolio = portfolioHistory.current
+    const lastPortfolio = last(portfolioHistory)
    const didPortfolioChange =
-      currPortfolio === undefined ||
-      currPortfolio.balance !== newPortfolio.balance ||
-      currPortfolio.totalDeposits !== newPortfolio.totalDeposits ||
-      currPortfolio.investmentValue !== newPortfolio.investmentValue
+      lastPortfolio === undefined ||
+      lastPortfolio.balance !== newPortfolio.balance ||
+      lastPortfolio.totalDeposits !== newPortfolio.totalDeposits ||
+      lastPortfolio.investmentValue !== newPortfolio.investmentValue

    const newProfit = calculateNewProfit(portfolioHistory, newPortfolio)

-    const metricsByContract = calculateMetricsByContract(
-      currentBets,
-      contractsById
-    )
-
-    const contractRatios = userContracts
-      .map((contract) => {
-        if (
-          !contract.flaggedByUsernames ||
-          contract.flaggedByUsernames?.length === 0
-        ) {
-          return 0
-        }
-        const contractRatio =
-          contract.flaggedByUsernames.length / (contract.uniqueBettorCount || 1)
-
-        return contractRatio
-      })
-      .filter((ratio) => ratio > 0)
-    const badResolutions = contractRatios.filter(
-      (ratio) => ratio > BAD_RESOLUTION_THRESHOLD
-    )
-    let newFractionResolvedCorrectly = 1
-    if (userContracts.length > 0) {
-      newFractionResolvedCorrectly =
-        (userContracts.length - badResolutions.length) / userContracts.length
-    }
-
    return {
      user,
      newCreatorVolume,
      newPortfolio,
      newProfit,
      didPortfolioChange,
-      newFractionResolvedCorrectly,
-      metricsByContract,
    }
  })

@ -210,61 +138,61 @@ export async function updateMetricsCore() {
  const nextLoanByUser = keyBy(userPayouts, (payout) => payout.user.id)

  const userUpdates = userMetrics.map(
-    ({ user, newCreatorVolume, newProfit, newFractionResolvedCorrectly }) => {
+    ({
+      user,
+      newCreatorVolume,
+      newPortfolio,
+      newProfit,
+      didPortfolioChange,
+    }) => {
      const nextLoanCached = nextLoanByUser[user.id]?.payout ?? 0
      return {
+        fieldUpdates: {
          doc: firestore.collection('users').doc(user.id),
          fields: {
            creatorVolumeCached: newCreatorVolume,
            profitCached: newProfit,
            nextLoanCached,
-          fractionResolvedCorrectly: newFractionResolvedCorrectly,
          },
-      }
-    }
-  )
-  await writeAsync(firestore, userUpdates)
+        },

-  const portfolioHistoryUpdates = filterDefined(
-    userMetrics.map(({ user, newPortfolio, didPortfolioChange }) => {
-      return didPortfolioChange
-        ? {
+        subcollectionUpdates: {
          doc: firestore
            .collection('users')
            .doc(user.id)
            .collection('portfolioHistory')
            .doc(),
-            fields: newPortfolio,
+          fields: didPortfolioChange ? newPortfolio : {},
+        },
      }
-        : null
-    })
-  )
-  await writeAsync(firestore, portfolioHistoryUpdates, 'set')
-
-  const contractMetricsUpdates = userMetrics.flatMap(
-    ({ user, metricsByContract }) => {
-      const collection = firestore
-        .collection('users')
-        .doc(user.id)
-        .collection('contract-metrics')
-      return metricsByContract.map((metrics) => ({
-        doc: collection.doc(metrics.contractId),
-        fields: metrics,
-      }))
    }
  )
-
-  await writeAsync(firestore, contractMetricsUpdates, 'set')
-
+  await writeAsync(
+    firestore,
+    userUpdates.map((u) => u.fieldUpdates)
+  )
+  await writeAsync(
+    firestore,
+    userUpdates
+      .filter((u) => !isEmpty(u.subcollectionUpdates.fields))
+      .map((u) => u.subcollectionUpdates),
+    'set'
+  )
  log(`Updated metrics for ${users.length} users.`)

  try {
    const groupUpdates = groups.map((group, index) => {
      const groupContractIds = contractsByGroup[index] as GroupContractDoc[]
-      const groupContracts = filterDefined(
-        groupContractIds.map((e) => contractsById[e.contractId])
-      )
-      const bets = groupContracts.map((e) => betsByContract[e.id] ?? [])
+      const groupContracts = groupContractIds
+        .map((e) => contractsById[e.contractId])
+        .filter((e) => e !== undefined) as Contract[]
+      const bets = groupContracts.map((e) => {
+        if (e != null && e.id in betsByContract) {
+          return betsByContract[e.id] ?? []
+        } else {
+          return []
+        }
+      })

      const creatorScores = scoreCreators(groupContracts)
      const traderScores = scoreTraders(groupContracts, bets)
@ -296,46 +224,3 @@ const topUserScores = (scores: { [userId: string]: number }) => {
 }

 type GroupContractDoc = { contractId: string; createdTime: number }
-
-const BAD_RESOLUTION_THRESHOLD = 0.1
-
-const loadPortfolioHistory = async (users: User[]) => {
-  const now = Date.now()
-  const userPortfolioHistory = await batchedWaitAll(
-    users.map((user) => async () => {
-      const query = firestore
-        .collection('users')
-        .doc(user.id)
-        .collection('portfolioHistory')
-        .orderBy('timestamp', 'desc')
-        .limit(1)
-
-      const portfolioMetrics = await Promise.all([
-        getValues<PortfolioMetrics>(query),
-        getValues<PortfolioMetrics>(
-          query.where('timestamp', '<', now - DAY_MS)
-        ),
-        getValues<PortfolioMetrics>(
-          query.where('timestamp', '<', now - 7 * DAY_MS)
-        ),
-        getValues<PortfolioMetrics>(
-          query.where('timestamp', '<', now - 30 * DAY_MS)
-        ),
-      ])
-      const [current, day, week, month] = portfolioMetrics.map(
-        (p) => p[0] as PortfolioMetrics | undefined
-      )
-
-      return {
-        userId: user.id,
-        current,
-        day,
-        week,
-        month,
-      }
-    }),
-    100
-  )
-
-  return keyBy(userPortfolioHistory, (p) => p.userId)
-}
--- a/functions/src/update-stats.ts
+++ b/functions/src/update-stats.ts
@ -18,7 +18,7 @@ import { average } from '../../common/util/math'

 const firestore = admin.firestore()

-const numberOfDays = 180
+const numberOfDays = 90

 const getBetsQuery = (startTime: number, endTime: number) =>
  firestore
--- a/functions/src/utils.ts
+++ b/functions/src/utils.ts
@ -1,8 +1,7 @@
 import * as admin from 'firebase-admin'
 import fetch from 'node-fetch'
-import { FieldValue, Transaction } from 'firebase-admin/firestore'
-import { chunk, groupBy, mapValues, sumBy } from 'lodash'

+import { chunk } from 'lodash'
 import { Contract } from '../../common/contract'
 import { PrivateUser, User } from '../../common/user'
 import { Group } from '../../common/group'
@ -48,7 +47,7 @@ export const writeAsync = async (
    const batch = db.batch()
    for (const { doc, fields } of chunks[i]) {
      if (operationType === 'update') {
-        batch.update(doc, fields as any)
+        batch.update(doc, fields)
      } else {
        batch.set(doc, fields)
      }
@ -113,12 +112,6 @@ export const getAllPrivateUsers = async () => {
  return users.docs.map((doc) => doc.data() as PrivateUser)
 }

-export const getAllUsers = async () => {
-  const firestore = admin.firestore()
-  const users = await firestore.collection('users').get()
-  return users.docs.map((doc) => doc.data() as User)
-}
-
 export const getUserByUsername = async (username: string) => {
  const firestore = admin.firestore()
  const snap = await firestore
@ -129,29 +122,38 @@ export const getUserByUsername = async (username: string) => {
  return snap.empty ? undefined : (snap.docs[0].data() as User)
 }

-const firestore = admin.firestore()
-
 const updateUserBalance = (
-  transaction: Transaction,
  userId: string,
-  balanceDelta: number,
-  depositDelta: number
+  delta: number,
+  isDeposit = false
 ) => {
+  const firestore = admin.firestore()
+  return firestore.runTransaction(async (transaction) => {
    const userDoc = firestore.doc(`users/${userId}`)
+    const userSnap = await transaction.get(userDoc)
+    if (!userSnap.exists) return
+    const user = userSnap.data() as User

-  // Note: Balance is allowed to go negative.
-  transaction.update(userDoc, {
-    balance: FieldValue.increment(balanceDelta),
-    totalDeposits: FieldValue.increment(depositDelta),
+    const newUserBalance = user.balance + delta
+
+    // if (newUserBalance < 0)
+    //   throw new Error(
+    //     `User (${userId}) balance cannot be negative: ${newUserBalance}`
+    //   )
+
+    if (isDeposit) {
+      const newTotalDeposits = (user.totalDeposits || 0) + delta
+      transaction.update(userDoc, { totalDeposits: newTotalDeposits })
+    }
+
+    transaction.update(userDoc, { balance: newUserBalance })
  })
 }

 export const payUser = (userId: string, payout: number, isDeposit = false) => {
  if (!isFinite(payout)) throw new Error('Payout is not finite: ' + payout)

-  return firestore.runTransaction(async (transaction) => {
-    updateUserBalance(transaction, userId, payout, isDeposit ? payout : 0)
-  })
+  return updateUserBalance(userId, payout, isDeposit)
 }

 export const chargeUser = (
@ -162,67 +164,7 @@ export const chargeUser = (
  if (!isFinite(charge) || charge <= 0)
    throw new Error('User charge is not positive: ' + charge)

-  return payUser(userId, -charge, isAnte)
-}
-
-const checkAndMergePayouts = (
-  payouts: {
-    userId: string
-    payout: number
-    deposit?: number
-  }[]
-) => {
-  for (const { payout, deposit } of payouts) {
-    if (!isFinite(payout)) {
-      throw new Error('Payout is not finite: ' + payout)
-    }
-    if (deposit !== undefined && !isFinite(deposit)) {
-      throw new Error('Deposit is not finite: ' + deposit)
-    }
-  }
-
-  const groupedPayouts = groupBy(payouts, 'userId')
-  return Object.values(
-    mapValues(groupedPayouts, (payouts, userId) => ({
-      userId,
-      payout: sumBy(payouts, 'payout'),
-      deposit: sumBy(payouts, (p) => p.deposit ?? 0),
-    }))
-  )
-}
-
-// Max 500 users in one transaction.
-export const payUsers = (
-  transaction: Transaction,
-  payouts: {
-    userId: string
-    payout: number
-    deposit?: number
-  }[]
-) => {
-  const mergedPayouts = checkAndMergePayouts(payouts)
-  for (const { userId, payout, deposit } of mergedPayouts) {
-    updateUserBalance(transaction, userId, payout, deposit)
-  }
-}
-
-export const payUsersMultipleTransactions = async (
-  payouts: {
-    userId: string
-    payout: number
-    deposit?: number
-  }[]
-) => {
-  const mergedPayouts = checkAndMergePayouts(payouts)
-  const payoutChunks = chunk(mergedPayouts, 500)
-
-  for (const payoutChunk of payoutChunks) {
-    await firestore.runTransaction(async (transaction) => {
-      for (const { userId, payout, deposit } of payoutChunk) {
-        updateUserBalance(transaction, userId, payout, deposit)
-      }
-    })
-  }
+  return updateUserBalance(userId, -charge, isAnte)
 }

 export const getContractPath = (contract: Contract) => {
--- a/functions/src/weekly-markets-emails.ts
+++ b/functions/src/weekly-markets-emails.ts
@ -4,24 +4,21 @@ import * as admin from 'firebase-admin'
 import { Contract } from '../../common/contract'
 import {
  getAllPrivateUsers,
-  getGroup,
  getPrivateUser,
  getUser,
  getValues,
  isProd,
  log,
 } from './utils'
-import { createRNG, shuffle } from '../../common/util/random'
-import { DAY_MS, HOUR_MS } from '../../common/util/time'
-import { filterDefined } from '../../common/util/array'
-import { Follow } from '../../common/follow'
-import { countBy, uniq, uniqBy } from 'lodash'
 import { sendInterestingMarketsEmail } from './emails'
+import { createRNG, shuffle } from '../../common/util/random'
+import { DAY_MS } from '../../common/util/time'
+import { filterDefined } from '../../common/util/array'

 export const weeklyMarketsEmails = functions
  .runWith({ secrets: ['MAILGUN_KEY'], memory: '4GB' })
-  // every minute on Monday for 2 hours starting at 12pm PT (UTC -07:00)
-  .pubsub.schedule('* 19-20 * * 1')
+  // every minute on Monday for an hour at 12pm PT (UTC -07:00)
+  .pubsub.schedule('* 19 * * 1')
  .timeZone('Etc/UTC')
  .onRun(async () => {
    await sendTrendingMarketsEmailsToAllUsers()
@ -43,30 +40,20 @@ export async function getTrendingContracts() {
  )
 }

-export async function sendTrendingMarketsEmailsToAllUsers() {
+async function sendTrendingMarketsEmailsToAllUsers() {
  const numContractsToSend = 6
  const privateUsers = isProd()
    ? await getAllPrivateUsers()
-    : filterDefined([
-        await getPrivateUser('6hHpzvRG0pMq8PNJs7RZj2qlZGn2'), // dev Ian
-      ])
+    : filterDefined([await getPrivateUser('6hHpzvRG0pMq8PNJs7RZj2qlZGn2')])
+  // get all users that haven't unsubscribed from weekly emails
  const privateUsersToSendEmailsTo = privateUsers
-    // Get all users that haven't unsubscribed from weekly emails
-    .filter(
-      (user) =>
+    .filter((user) => {
+      return (
        user.notificationPreferences.trending_markets.includes('email') &&
        !user.weeklyTrendingEmailSent
      )
-    .slice(0, 90) // Send the emails out in batches
-
-  // For testing different users on prod: (only send ian an email though)
-  // const privateUsersToSendEmailsTo = filterDefined([
-  //   await getPrivateUser('AJwLWoo3xue32XIiAVrL5SyR1WB2'), // prod Ian
-  //   // isProd()
-  //   await getPrivateUser('FptiiMZZ6dQivihLI8MYFQ6ypSw1'), // prod Mik
-  //   //   : await getPrivateUser('6hHpzvRG0pMq8PNJs7RZj2qlZGn2'), // dev Ian
-  // ])
-
+    })
+    .slice(150) // Send the emails out in batches
  log(
    'Sending weekly trending emails to',
    privateUsersToSendEmailsTo.length,
@ -83,358 +70,42 @@ export async function sendTrendingMarketsEmailsToAllUsers() {
        !contract.groupSlugs?.includes('manifold-features') &&
        !contract.groupSlugs?.includes('manifold-6748e065087e')
    )
-    .slice(0, 50)
+    .slice(0, 20)
+  log(
+    `Found ${trendingContracts.length} trending contracts:\n`,
+    trendingContracts.map((c) => c.question).join('\n ')
+  )

-  const uniqueTrendingContracts = removeSimilarQuestions(
-    trendingContracts,
-    trendingContracts,
-    true
-  ).slice(0, 20)
-
-  await Promise.all(
-    privateUsersToSendEmailsTo.map(async (privateUser) => {
+  // TODO: convert to Promise.all
+  for (const privateUser of privateUsersToSendEmailsTo) {
    if (!privateUser.email) {
      log(`No email for ${privateUser.username}`)
-        return
+      continue
    }
-
-      const unbetOnFollowedMarkets = await getUserUnBetOnFollowsMarkets(
-        privateUser.id
-      )
-      const unBetOnGroupMarkets = await getUserUnBetOnGroupsMarkets(
-        privateUser.id,
-        unbetOnFollowedMarkets
-      )
-      const similarBettorsMarkets = await getSimilarBettorsMarkets(
-        privateUser.id,
-        unBetOnGroupMarkets
-      )
-
-      const marketsAvailableToSend = uniqBy(
-        [
-          ...chooseRandomSubset(unbetOnFollowedMarkets, 2),
-          // // Most people will belong to groups but may not follow other users,
-          // so choose more from the other subsets if the followed markets is sparse
-          ...chooseRandomSubset(
-            unBetOnGroupMarkets,
-            unbetOnFollowedMarkets.length < 2 ? 3 : 2
-          ),
-          ...chooseRandomSubset(
-            similarBettorsMarkets,
-            unbetOnFollowedMarkets.length < 2 ? 3 : 2
-          ),
-        ],
-        (contract) => contract.id
-      )
-      // // at least send them trending contracts if nothing else
-      if (marketsAvailableToSend.length < numContractsToSend) {
-        const trendingMarketsToSend =
-          numContractsToSend - marketsAvailableToSend.length
-        log(
-          `not enough personalized markets, sending ${trendingMarketsToSend} trending`
-        )
-        marketsAvailableToSend.push(
-          ...removeSimilarQuestions(
-            uniqueTrendingContracts,
-            marketsAvailableToSend,
-            false
-          )
-            .filter(
-              (contract) => !contract.uniqueBettorIds?.includes(privateUser.id)
-            )
-            .slice(0, trendingMarketsToSend)
-        )
-      }
-
-      if (marketsAvailableToSend.length < numContractsToSend) {
-        log(
-          'not enough new, unbet-on contracts to send to user',
-          privateUser.id
-        )
+    const contractsAvailableToSend = trendingContracts.filter((contract) => {
+      return !contract.uniqueBettorIds?.includes(privateUser.id)
+    })
+    if (contractsAvailableToSend.length < numContractsToSend) {
+      log('not enough new, unbet-on contracts to send to user', privateUser.id)
      await firestore.collection('private-users').doc(privateUser.id).update({
        weeklyTrendingEmailSent: true,
      })
-        return
+      continue
    }
    // choose random subset of contracts to send to user
    const contractsToSend = chooseRandomSubset(
-        marketsAvailableToSend,
+      contractsAvailableToSend,
      numContractsToSend
    )

    const user = await getUser(privateUser.id)
-      if (!user) return
+    if (!user) continue

-      log(
-        'sending contracts:',
-        contractsToSend.map((c) => c.question + ' ' + c.popularityScore)
-      )
-      // if they don't have enough markets, find user bets and get the other bettor ids who most overlap on those markets, then do the same thing as above for them
    await sendInterestingMarketsEmail(user, privateUser, contractsToSend)
    await firestore.collection('private-users').doc(user.id).update({
      weeklyTrendingEmailSent: true,
    })
-    })
-  )
-}
-
-const MINIMUM_POPULARITY_SCORE = 10
-
-const getUserUnBetOnFollowsMarkets = async (userId: string) => {
-  const follows = await getValues<Follow>(
-    firestore.collection('users').doc(userId).collection('follows')
-  )
-
-  const unBetOnContractsFromFollows = await Promise.all(
-    follows.map(async (follow) => {
-      const unresolvedContracts = await getValues<Contract>(
-        firestore
-          .collection('contracts')
-          .where('isResolved', '==', false)
-          .where('visibility', '==', 'public')
-          .where('creatorId', '==', follow.userId)
-          // can't use multiple inequality (/orderBy) operators on different fields,
-          // so have to filter for closed contracts separately
-          .orderBy('popularityScore', 'desc')
-          .limit(50)
-      )
-      // filter out contracts that have close times less than 6 hours from now
-      const openContracts = unresolvedContracts.filter(
-        (contract) => (contract?.closeTime ?? 0) > Date.now() + 6 * HOUR_MS
-      )
-
-      return openContracts.filter(
-        (contract) => !contract.uniqueBettorIds?.includes(userId)
-      )
-    })
-  )
-
-  const sortedMarkets = uniqBy(
-    unBetOnContractsFromFollows.flat(),
-    (contract) => contract.id
-  )
-    .filter(
-      (contract) =>
-        contract.popularityScore !== undefined &&
-        contract.popularityScore > MINIMUM_POPULARITY_SCORE
-    )
-    .sort((a, b) => (b.popularityScore ?? 0) - (a.popularityScore ?? 0))
-
-  const uniqueSortedMarkets = removeSimilarQuestions(
-    sortedMarkets,
-    sortedMarkets,
-    true
-  )
-
-  const topSortedMarkets = uniqueSortedMarkets.slice(0, 10)
-  // log(
-  //   'top 10 sorted markets by followed users',
-  //   topSortedMarkets.map((c) => c.question + ' ' + c.popularityScore)
-  // )
-  return topSortedMarkets
-}
-
-const getUserUnBetOnGroupsMarkets = async (
-  userId: string,
-  differentThanTheseContracts: Contract[]
-) => {
-  const snap = await firestore
-    .collectionGroup('groupMembers')
-    .where('userId', '==', userId)
-    .get()
-
-  const groupIds = filterDefined(
-    snap.docs.map((doc) => doc.ref.parent.parent?.id)
-  )
-  const groups = filterDefined(
-    await Promise.all(groupIds.map(async (groupId) => await getGroup(groupId)))
-  )
-  if (groups.length === 0) return []
-
-  const unBetOnContractsFromGroups = await Promise.all(
-    groups.map(async (group) => {
-      const unresolvedContracts = await getValues<Contract>(
-        firestore
-          .collection('contracts')
-          .where('isResolved', '==', false)
-          .where('visibility', '==', 'public')
-          .where('groupSlugs', 'array-contains', group.slug)
-          // can't use multiple inequality (/orderBy) operators on different fields,
-          // so have to filter for closed contracts separately
-          .orderBy('popularityScore', 'desc')
-          .limit(50)
-      )
-      // filter out contracts that have close times less than 6 hours from now
-      const openContracts = unresolvedContracts.filter(
-        (contract) => (contract?.closeTime ?? 0) > Date.now() + 6 * HOUR_MS
-      )
-
-      return openContracts.filter(
-        (contract) => !contract.uniqueBettorIds?.includes(userId)
-      )
-    })
-  )
-
-  const sortedMarkets = uniqBy(
-    unBetOnContractsFromGroups.flat(),
-    (contract) => contract.id
-  )
-    .filter(
-      (contract) =>
-        contract.popularityScore !== undefined &&
-        contract.popularityScore > MINIMUM_POPULARITY_SCORE
-    )
-    .sort((a, b) => (b.popularityScore ?? 0) - (a.popularityScore ?? 0))
-
-  const uniqueSortedMarkets = removeSimilarQuestions(
-    sortedMarkets,
-    sortedMarkets,
-    true
-  )
-  const topSortedMarkets = removeSimilarQuestions(
-    uniqueSortedMarkets,
-    differentThanTheseContracts,
-    false
-  ).slice(0, 10)
-
-  // log(
-  //   'top 10 sorted group markets',
-  //   topSortedMarkets.map((c) => c.question + ' ' + c.popularityScore)
-  // )
-  return topSortedMarkets
-}
-
-// Gets markets followed by similar bettors and bet on by similar bettors
-const getSimilarBettorsMarkets = async (
-  userId: string,
-  differentThanTheseContracts: Contract[]
-) => {
-  // get contracts with unique bettor ids with this user
-  const contractsUserHasBetOn = await getValues<Contract>(
-    firestore
-      .collection('contracts')
-      .where('uniqueBettorIds', 'array-contains', userId)
-  )
-  if (contractsUserHasBetOn.length === 0) return []
-  // count the number of times each unique bettor id appears on those contracts
-  const bettorIdsToCounts = countBy(
-    contractsUserHasBetOn.map((contract) => contract.uniqueBettorIds).flat(),
-    (bettorId) => bettorId
-  )
-
-  // sort by number of times they appear with at least 2 appearances
-  const sortedBettorIds = Object.entries(bettorIdsToCounts)
-    .sort((a, b) => b[1] - a[1])
-    .filter((bettorId) => bettorId[1] > 2)
-    .map((entry) => entry[0])
-    .filter((bettorId) => bettorId !== userId)
-
-  // get the top 10 most similar bettors (excluding this user)
-  const similarBettorIds = sortedBettorIds.slice(0, 10)
-  if (similarBettorIds.length === 0) return []
-
-  // get contracts with unique bettor ids with this user
-  const contractsSimilarBettorsHaveBetOn = uniqBy(
-    (
-      await getValues<Contract>(
-        firestore
-          .collection('contracts')
-          .where(
-            'uniqueBettorIds',
-            'array-contains-any',
-            similarBettorIds.slice(0, 10)
-          )
-          .orderBy('popularityScore', 'desc')
-          .limit(200)
-      )
-    ).filter(
-      (contract) =>
-        !contract.uniqueBettorIds?.includes(userId) &&
-        (contract.popularityScore ?? 0) > MINIMUM_POPULARITY_SCORE
-    ),
-    (contract) => contract.id
-  )
-
-  // sort the contracts by how many times similar bettor ids are in their unique bettor ids array
-  const sortedContractsInSimilarBettorsBets = contractsSimilarBettorsHaveBetOn
-    .map((contract) => {
-      const appearances = contract.uniqueBettorIds?.filter((bettorId) =>
-        similarBettorIds.includes(bettorId)
-      ).length
-      return [contract, appearances] as [Contract, number]
-    })
-    .sort((a, b) => b[1] - a[1])
-    .map((entry) => entry[0])
-
-  const uniqueSortedContractsInSimilarBettorsBets = removeSimilarQuestions(
-    sortedContractsInSimilarBettorsBets,
-    sortedContractsInSimilarBettorsBets,
-    true
-  )
-
-  const topMostSimilarContracts = removeSimilarQuestions(
-    uniqueSortedContractsInSimilarBettorsBets,
-    differentThanTheseContracts,
-    false
-  ).slice(0, 10)
-
-  // log(
-  //   'top 10 sorted contracts other similar bettors have bet on',
-  //   topMostSimilarContracts.map((c) => c.question)
-  // )
-
-  return topMostSimilarContracts
-}
-
-// search contract array by question and remove contracts with 3 matching words in the question
-const removeSimilarQuestions = (
-  contractsToFilter: Contract[],
-  byContracts: Contract[],
-  allowExactSameContracts: boolean
-) => {
-  // log(
-  //   'contracts to filter by',
-  //   byContracts.map((c) => c.question + ' ' + c.popularityScore)
-  // )
-  let contractsToRemove: Contract[] = []
-  byContracts.length > 0 &&
-    byContracts.forEach((contract) => {
-      const contractQuestion = stripNonAlphaChars(
-        contract.question.toLowerCase()
-      )
-      const contractQuestionWords = uniq(contractQuestion.split(' ')).filter(
-        (w) => !IGNORE_WORDS.includes(w)
-      )
-      contractsToRemove = contractsToRemove.concat(
-        contractsToFilter.filter(
-          // Remove contracts with more than 2 matching (uncommon) words and a lower popularity score
-          (c2) => {
-            const significantOverlap =
-              // TODO: we should probably use a library for comparing strings/sentiments
-              uniq(
-                stripNonAlphaChars(c2.question.toLowerCase()).split(' ')
-              ).filter((word) => contractQuestionWords.includes(word)).length >
-              2
-            const lessPopular =
-              (c2.popularityScore ?? 0) < (contract.popularityScore ?? 0)
-            return (
-              (significantOverlap && lessPopular) ||
-              (allowExactSameContracts ? false : c2.id === contract.id)
-            )
  }
-        )
-      )
-    })
-  // log(
-  //   'contracts to filter out',
-  //   contractsToRemove.map((c) => c.question)
-  // )
-
-  const returnContracts = contractsToFilter.filter(
-    (cf) => !contractsToRemove.map((c) => c.id).includes(cf.id)
-  )
-
-  return returnContracts
 }

 const fiveMinutes = 5 * 60 * 1000
@ -445,40 +116,3 @@ function chooseRandomSubset(contracts: Contract[], count: number) {
  shuffle(contracts, rng)
  return contracts.slice(0, count)
 }
-
-function stripNonAlphaChars(str: string) {
-  return str.replace(/[^\w\s']|_/g, '').replace(/\s+/g, ' ')
-}
-
-const IGNORE_WORDS = [
-  'the',
-  'a',
-  'an',
-  'and',
-  'or',
-  'of',
-  'to',
-  'in',
-  'on',
-  'will',
-  'be',
-  'is',
-  'are',
-  'for',
-  'by',
-  'at',
-  'from',
-  'what',
-  'when',
-  'which',
-  'that',
-  'it',
-  'as',
-  'if',
-  'then',
-  'than',
-  'but',
-  'have',
-  'has',
-  'had',
-]
--- a/functions/src/weekly-portfolio-emails.ts
+++ b/functions/src/weekly-portfolio-emails.ts
@ -20,8 +20,8 @@ import { sendWeeklyPortfolioUpdateEmail } from './emails'
 import { contractUrl } from './utils'
 import { Txn } from '../../common/txn'
 import { formatMoney } from '../../common/util/format'
-import { getContractBetMetrics } from '../../common/calculate'

+// TODO: reset weeklyPortfolioUpdateEmailSent to false for all users at the start of each week
 export const weeklyPortfolioUpdateEmails = functions
  .runWith({ secrets: ['MAILGUN_KEY'], memory: '4GB' })
  // every minute on Friday for an hour at 12pm PT (UTC -07:00)
@ -36,7 +36,7 @@ const firestore = admin.firestore()
 export async function sendPortfolioUpdateEmailsToAllUsers() {
  const privateUsers = isProd()
    ? // ian & stephen's ids
-      // filterDefined([
+      // ? filterDefined([
      //   await getPrivateUser('AJwLWoo3xue32XIiAVrL5SyR1WB2'),
      //   await getPrivateUser('tlmGNz9kjXc2EteizMORes4qvWl2'),
      // ])
@ -48,7 +48,7 @@ export async function sendPortfolioUpdateEmailsToAllUsers() {
      return isProd()
        ? user.notificationPreferences.profit_loss_updates.includes('email') &&
            !user.weeklyPortfolioUpdateEmailSent
-        : user.notificationPreferences.profit_loss_updates.includes('email')
+        : true
    })
    // Send emails in batches
    .slice(0, 200)
@ -112,12 +112,12 @@ export async function sendPortfolioUpdateEmailsToAllUsers() {
      )
    )
  )
+  log('Found', contractsUsersBetOn.length, 'contracts')
+  let count = 0
  await Promise.all(
    privateUsersToSendEmailsTo.map(async (privateUser) => {
      const user = await getUser(privateUser.id)
-      // Don't send to a user unless they're over 5 days old
-      if (!user || user.createdTime > Date.now() - 5 * DAY_MS)
-        return await setEmailFlagAsSent(privateUser.id)
+      if (!user) return
      const userBets = usersBets[privateUser.id] as Bet[]
      const contractsUserBetOn = contractsUsersBetOn.filter((contract) =>
        userBets.some((bet) => bet.contractId === contract.id)
@ -165,43 +165,28 @@ export async function sendPortfolioUpdateEmailsToAllUsers() {
            const bets = userBets.filter(
              (bet) => bet.contractId === contract.id
            )
-            const previousBets = bets.filter(
-              (b) => b.createdTime < Date.now() - 7 * DAY_MS
-            )
-
-            const betsInLastWeek = bets.filter(
-              (b) => b.createdTime >= Date.now() - 7 * DAY_MS
-            )

            const marketProbabilityAWeekAgo =
              cpmmContract.prob - cpmmContract.probChanges.week
            const currentMarketProbability = cpmmContract.resolutionProbability
              ? cpmmContract.resolutionProbability
              : cpmmContract.prob
-
-            // TODO: returns 0 for resolved markets - doesn't include them
-            const betsMadeAWeekAgoValue = computeInvestmentValueCustomProb(
-              previousBets,
+            const betsValueAWeekAgo = computeInvestmentValueCustomProb(
+              bets.filter((b) => b.createdTime < Date.now() - 7 * DAY_MS),
              contract,
              marketProbabilityAWeekAgo
            )
-            const currentBetsMadeAWeekAgoValue =
-              computeInvestmentValueCustomProb(
-                previousBets,
+            const currentBetsValue = computeInvestmentValueCustomProb(
+              bets,
              contract,
              currentMarketProbability
            )
-            const betsMadeInLastWeekProfit = getContractBetMetrics(
-              contract,
-              betsInLastWeek
-            ).profit
-            const profit =
-              betsMadeInLastWeekProfit +
-              (currentBetsMadeAWeekAgoValue - betsMadeAWeekAgoValue)
+            const marketChange =
+              currentMarketProbability - marketProbabilityAWeekAgo
            return {
-              currentValue: currentBetsMadeAWeekAgoValue,
-              pastValue: betsMadeAWeekAgoValue,
-              profit,
+              currentValue: currentBetsValue,
+              pastValue: betsValueAWeekAgo,
+              difference: currentBetsValue - betsValueAWeekAgo,
              contractSlug: contract.slug,
              marketProbAWeekAgo: marketProbabilityAWeekAgo,
              questionTitle: contract.question,
@ -209,21 +194,36 @@ export async function sendPortfolioUpdateEmailsToAllUsers() {
              questionProb: cpmmContract.resolution
                ? cpmmContract.resolution
                : Math.round(cpmmContract.prob * 100) + '%',
-              profitStyle: `color: ${
-                profit > 0 ? 'rgba(0,160,0,1)' : '#a80000'
+              questionChange:
+                (marketChange > 0 ? '+' : '') +
+                Math.round(marketChange * 100) +
+                '%',
+              questionChangeStyle: `color: ${
+                currentMarketProbability > marketProbabilityAWeekAgo
+                  ? 'rgba(0,160,0,1)'
+                  : '#a80000'
              };`,
            } as PerContractInvestmentsData
          })
        ),
-        (differences) => Math.abs(differences.profit)
+        (differences) => Math.abs(differences.difference)
      ).reverse()

+      log(
+        'Found',
+        investmentValueDifferences.length,
+        'investment differences for user',
+        privateUser.id
+      )
+
      const [winningInvestments, losingInvestments] = partition(
        investmentValueDifferences.filter(
-          (diff) => diff.pastValue > 0.01 && Math.abs(diff.profit) > 1
+          (diff) =>
+            diff.pastValue > 0.01 &&
+            Math.abs(diff.difference / diff.pastValue) > 0.01 // difference is greater than 1%
        ),
        (investmentsData: PerContractInvestmentsData) => {
-          return investmentsData.profit > 0
+          return investmentsData.difference > 0
        }
      )
      // pick 3 winning investments and 3 losing investments
@ -236,37 +236,37 @@ export async function sendPortfolioUpdateEmailsToAllUsers() {
        worstInvestments.length === 0 &&
        usersToContractsCreated[privateUser.id].length === 0
      ) {
-        log(
-          `No bets in last week, no market movers, no markets created. Not sending an email to ${privateUser.email} .`
-        )
-        return await setEmailFlagAsSent(privateUser.id)
+        log('No bets in last week, no market movers, no markets created')
+        await firestore.collection('private-users').doc(privateUser.id).update({
+          weeklyPortfolioUpdateEmailSent: true,
+        })
+        return
      }
-      // Set the flag beforehand just to be safe
-      await setEmailFlagAsSent(privateUser.id)
      await sendWeeklyPortfolioUpdateEmail(
        user,
        privateUser,
        topInvestments.concat(worstInvestments) as PerContractInvestmentsData[],
        performanceData
      )
-    })
-  )
-}
-
-async function setEmailFlagAsSent(privateUserId: string) {
-  await firestore.collection('private-users').doc(privateUserId).update({
+      await firestore.collection('private-users').doc(privateUser.id).update({
        weeklyPortfolioUpdateEmailSent: true,
      })
+      log('Sent weekly portfolio update email to', privateUser.email)
+      count++
+      log('sent out emails to user count:', count)
+    })
+  )
 }

 export type PerContractInvestmentsData = {
  questionTitle: string
  questionUrl: string
  questionProb: string
-  profitStyle: string
+  questionChange: string
+  questionChangeStyle: string
  currentValue: number
  pastValue: number
-  profit: number
+  difference: number
 }

 export type OverallPerformanceData = {
--- a/functions/src/withdraw-liquidity.ts
+++ b/functions/src/withdraw-liquidity.ts
@ -0,0 +1,121 @@
+import * as admin from 'firebase-admin'
+import { z } from 'zod'
+
+import { CPMMContract } from '../../common/contract'
+import { User } from '../../common/user'
+import { subtractObjects } from '../../common/util/object'
+import { LiquidityProvision } from '../../common/liquidity-provision'
+import { getUserLiquidityShares } from '../../common/calculate-cpmm'
+import { Bet } from '../../common/bet'
+import { getProbability } from '../../common/calculate'
+import { noFees } from '../../common/fees'
+
+import { APIError, newEndpoint, validate } from './api'
+import { redeemShares } from './redeem-shares'
+
+const bodySchema = z.object({
+  contractId: z.string(),
+})
+
+export const withdrawliquidity = newEndpoint({}, async (req, auth) => {
+  const { contractId } = validate(bodySchema, req.body)
+
+  return await firestore
+    .runTransaction(async (trans) => {
+      const lpDoc = firestore.doc(`users/${auth.uid}`)
+      const lpSnap = await trans.get(lpDoc)
+      if (!lpSnap.exists) throw new APIError(400, 'User not found.')
+      const lp = lpSnap.data() as User
+
+      const contractDoc = firestore.doc(`contracts/${contractId}`)
+      const contractSnap = await trans.get(contractDoc)
+      if (!contractSnap.exists) throw new APIError(400, 'Contract not found.')
+      const contract = contractSnap.data() as CPMMContract
+
+      const liquidityCollection = firestore.collection(
+        `contracts/${contractId}/liquidity`
+      )
+
+      const liquiditiesSnap = await trans.get(liquidityCollection)
+
+      const liquidities = liquiditiesSnap.docs.map(
+        (doc) => doc.data() as LiquidityProvision
+      )
+
+      const userShares = getUserLiquidityShares(
+        auth.uid,
+        contract,
+        liquidities,
+        true
+      )
+
+      // zero all added amounts for now
+      // can add support for partial withdrawals in the future
+      liquiditiesSnap.docs
+        .filter(
+          (_, i) => !liquidities[i].isAnte && liquidities[i].userId === auth.uid
+        )
+        .forEach((doc) => trans.update(doc.ref, { amount: 0 }))
+
+      const payout = Math.min(...Object.values(userShares))
+      if (payout <= 0) return {}
+
+      const newBalance = lp.balance + payout
+      const newTotalDeposits = lp.totalDeposits + payout
+      trans.update(lpDoc, {
+        balance: newBalance,
+        totalDeposits: newTotalDeposits,
+      } as Partial<User>)
+
+      const newPool = subtractObjects(contract.pool, userShares)
+
+      const minPoolShares = Math.min(...Object.values(newPool))
+      const adjustedTotal = contract.totalLiquidity - payout
+
+      // total liquidity is a bogus number; use minPoolShares to prevent from going negative
+      const newTotalLiquidity = Math.max(adjustedTotal, minPoolShares)
+
+      trans.update(contractDoc, {
+        pool: newPool,
+        totalLiquidity: newTotalLiquidity,
+      })
+
+      const prob = getProbability(contract)
+
+      // surplus shares become user's bets
+      const bets = Object.entries(userShares)
+        .map(([outcome, shares]) =>
+          shares - payout < 1 // don't create bet if less than 1 share
+            ? undefined
+            : ({
+                userId: auth.uid,
+                contractId: contract.id,
+                amount:
+                  (outcome === 'YES' ? prob : 1 - prob) * (shares - payout),
+                shares: shares - payout,
+                outcome,
+                probBefore: prob,
+                probAfter: prob,
+                createdTime: Date.now(),
+                isLiquidityProvision: true,
+                fees: noFees,
+              } as Omit<Bet, 'id'>)
+        )
+        .filter((x) => x !== undefined)
+
+      for (const bet of bets) {
+        const doc = firestore.collection(`contracts/${contract.id}/bets`).doc()
+        trans.create(doc, { id: doc.id, ...bet })
+      }
+
+      return userShares
+    })
+    .then(async (result) => {
+      // redeem surplus bet with pre-existing bets
+      await redeemShares(auth.uid, contractId)
+      console.log('userid', auth.uid, 'withdraws', result)
+      return result
+    })
+})
+
+const firestore = admin.firestore()
--- a/og-image/api/_lib/template.ts
+++ b/og-image/api/_lib/template.ts
@ -14,6 +14,11 @@ export function getHtml(parsedReq: ParsedRequest) {
    numericValue,
    resolution,
  } = parsedReq
+  const MAX_QUESTION_CHARS = 100
+  const truncatedQuestion =
+    question.length > MAX_QUESTION_CHARS
+      ? question.slice(0, MAX_QUESTION_CHARS) + '...'
+      : question
  const hideAvatar = creatorAvatarUrl ? '' : 'hidden'

  let resolutionColor = 'text-primary'
@ -64,7 +69,7 @@ export function getHtml(parsedReq: ParsedRequest) {
        <meta charset="utf-8">
        <title>Generated Image</title>
        <meta name="viewport" content="width=device-width, initial-scale=1">
-        <script src="https://cdn.tailwindcss.com?plugins=line-clamp"></script>
+        <script src="https://cdn.tailwindcss.com"></script>
    </head>
    <style>
        ${getTemplateCss(theme, fontSize)}
@ -104,8 +109,8 @@ export function getHtml(parsedReq: ParsedRequest) {
      </div>

      <div class="flex flex-row justify-between gap-12 pt-36">
-        <div class="text-indigo-700 text-6xl leading-tight line-clamp-4">
-          ${question}
+        <div class="text-indigo-700 text-6xl leading-tight">
+          ${truncatedQuestion}
        </div>
        <div class="flex flex-col">
                    ${
@ -122,7 +127,7 @@ export function getHtml(parsedReq: ParsedRequest) {

      <!-- Metadata -->
      <div class="absolute bottom-16">
-        <div class="text-gray-500 text-3xl max-w-[80vw] line-clamp-2">
+        <div class="text-gray-500 text-3xl max-w-[80vw]">
          ${metadata}
        </div>
      </div>
--- a/package.json
+++ b/package.json
@ -24,5 +24,8 @@
    "prettier": "2.7.1",
    "ts-node": "10.9.1",
    "typescript": "4.8.2"
+  },
+  "resolutions": {
+    "@types/react": "17.0.43"
  }
 }
--- a/web/.eslintrc.js
+++ b/web/.eslintrc.js
@ -22,9 +22,8 @@ module.exports = {
    '@next/next/no-typos': 'off',
    'linebreak-style': ['error', 'unix'],
    'lodash/import-scope': [2, 'member'],
-    'unused-imports/no-unused-imports': 'warn',
+    'unused-imports/no-unused-imports': 'error',
  },
-  ignorePatterns: ['/public/mtg/*'],
  env: {
    browser: true,
    node: true,
--- a/web/.gitignore
+++ b/web/.gitignore
@ -3,4 +3,3 @@
 node_modules
 out
 tsconfig.tsbuildinfo
-.env*
--- a/web/components/NoSEO.tsx
+++ b/web/components/NoSEO.tsx
@ -1,10 +0,0 @@
-import Head from 'next/head'
-
-/** Exclude page from search results */
-export function NoSEO() {
-  return (
-    <Head>
-      <meta name="robots" content="noindex,follow" />
-    </Head>
-  )
-}
--- a/web/components/SEO.tsx
+++ b/web/components/SEO.tsx
@ -15,7 +15,7 @@ export function SEO(props: {

  return (
    <Head>
-      <title>{`${title} | Manifold Markets`}</title>
+      <title>{title} | Manifold Markets</title>

      <meta
        property="og:title"
--- a/web/components/add-funds-button.tsx
+++ b/web/components/add-funds-button.tsx
@ -0,0 +1,84 @@
+import clsx from 'clsx'
+import { useEffect, useState } from 'react'
+
+import { useUser } from 'web/hooks/use-user'
+import { checkoutURL } from 'web/lib/service/stripe'
+import { FundsSelector } from './yes-no-selector'
+
+export function AddFundsButton(props: { className?: string }) {
+  const { className } = props
+  const user = useUser()
+
+  const [amountSelected, setAmountSelected] = useState<1000 | 2500 | 10000>(
+    2500
+  )
+
+  const location = useLocation()
+
+  return (
+    <>
+      <label
+        htmlFor="add-funds"
+        className={clsx(
+          'btn btn-xs btn-outline modal-button font-normal normal-case',
+          className
+        )}
+      >
+        Get M$
+      </label>
+      <input type="checkbox" id="add-funds" className="modal-toggle" />
+
+      <div className="modal">
+        <div className="modal-box">
+          <div className="mb-6 text-xl">Get Mana</div>
+
+          <div className="mb-6 text-gray-500">
+            Buy mana (M$) to trade in your favorite markets. <br /> (Not
+            redeemable for cash.)
+          </div>
+
+          <div className="mb-2 text-sm text-gray-500">Amount</div>
+          <FundsSelector
+            selected={amountSelected}
+            onSelect={setAmountSelected}
+          />
+
+          <div className="mt-6">
+            <div className="mb-1 text-sm text-gray-500">Price USD</div>
+            <div className="text-xl">
+              ${Math.round(amountSelected / 100)}.00
+            </div>
+          </div>
+
+          <div className="modal-action">
+            <label htmlFor="add-funds" className={clsx('btn btn-ghost')}>
+              Back
+            </label>
+
+            <form
+              action={checkoutURL(user?.id || '', amountSelected, location)}
+              method="POST"
+            >
+              <button
+                type="submit"
+                className="btn btn-primary bg-gradient-to-r from-indigo-500 to-blue-500 px-10 font-medium hover:from-indigo-600 hover:to-blue-600"
+              >
+                Checkout
+              </button>
+            </form>
+          </div>
+        </div>
+      </div>
+    </>
+  )
+}
+
+// needed in next js
+// window not loaded at runtime
+const useLocation = () => {
+  const [href, setHref] = useState('')
+  useEffect(() => {
+    setHref(window.location.href)
+  }, [])
+  return href
+}
--- a/web/components/add-funds-modal.tsx
+++ b/web/components/add-funds-modal.tsx
@ -1,58 +0,0 @@
-import { manaToUSD } from 'common/util/format'
-import { useState } from 'react'
-import { useUser } from 'web/hooks/use-user'
-import { checkoutURL } from 'web/lib/service/stripe'
-import { Button } from './button'
-import { Modal } from './layout/modal'
-import { FundsSelector } from './yes-no-selector'
-
-export function AddFundsModal(props: {
-  open: boolean
-  setOpen(open: boolean): void
-}) {
-  const { open, setOpen } = props
-
-  const user = useUser()
-
-  const [amountSelected, setAmountSelected] = useState<1000 | 2500 | 10000>(
-    2500
-  )
-
-  return (
-    <Modal open={open} setOpen={setOpen} className="rounded-md bg-white p-8">
-      <div className="mb-6 text-xl text-indigo-700">Get Mana</div>
-
-      <div className="mb-6 text-gray-700">
-        Buy mana (M$) to trade in your favorite markets. <br /> (Not redeemable
-        for cash.)
-      </div>
-
-      <div className="mb-2 text-sm text-gray-500">Amount</div>
-      <FundsSelector selected={amountSelected} onSelect={setAmountSelected} />
-
-      <div className="mt-6">
-        <div className="mb-1 text-sm text-gray-500">Price USD</div>
-        <div className="text-xl">{manaToUSD(amountSelected)}</div>
-      </div>
-
-      <div className="flex">
-        <Button color="gray-white" onClick={() => setOpen(false)}>
-          Back
-        </Button>
-
-        <form
-          action={checkoutURL(
-            user?.id || '',
-            amountSelected,
-            window.location.href
-          )}
-          method="POST"
-        >
-          <Button type="submit" color="gradient">
-            Checkout
-          </Button>
-        </form>
-      </div>
-    </Modal>
-  )
-}
--- a/web/components/amount-input.tsx
+++ b/web/components/amount-input.tsx
@ -1,14 +1,12 @@
 import clsx from 'clsx'
-import React, { useState } from 'react'
+import React from 'react'
 import { useUser } from 'web/hooks/use-user'
 import { formatMoney } from 'common/util/format'
 import { Col } from './layout/col'
+import { SiteLink } from './site-link'
 import { ENV_CONFIG } from 'common/envs/constants'
+import { useWindowSize } from 'web/hooks/use-window-size'
 import { Row } from './layout/row'
-import { AddFundsModal } from './add-funds-modal'
-import { Input } from './input'
-import Slider from 'rc-slider'
-import 'rc-slider/assets/index.css'

 export function AmountInput(props: {
  amount: number | undefined
@ -38,45 +36,44 @@ export function AmountInput(props: {
    onChange(isInvalid ? undefined : amount)
  }

-  const [addFundsModalOpen, setAddFundsModalOpen] = useState(false)
+  const { width } = useWindowSize()
+  const isMobile = (width ?? 0) < 768

  return (
    <>
-      <Col className={clsx('relative', className)}>
-        <label className="font-sm md:font-lg relative">
-          <span className="text-greyscale-4 absolute top-1/2 my-auto ml-2 -translate-y-1/2">
+      <Col className={className}>
+        <label className="font-sm md:font-lg">
+          <span className={clsx('text-greyscale-4 absolute ml-2 mt-[9px]')}>
            {label}
          </span>
-          <Input
-            className={clsx('w-24 pl-9 !text-base md:w-auto', inputClassName)}
+          <input
+            className={clsx(
+              'placeholder:text-greyscale-4 border-greyscale-2 rounded-md pl-9',
+              error && 'input-error',
+              isMobile ? 'w-24' : '',
+              inputClassName
+            )}
            ref={inputRef}
            type="text"
            pattern="[0-9]*"
            inputMode="numeric"
            placeholder="0"
            maxLength={6}
+            autoFocus={!isMobile}
            value={amount ?? ''}
-            error={!!error}
            disabled={disabled}
            onChange={(e) => onAmountChange(e.target.value)}
          />
        </label>

        {error && (
-          <div className="absolute -bottom-5 whitespace-nowrap text-xs font-medium tracking-wide text-red-500">
+          <div className="absolute mt-11 whitespace-nowrap text-xs font-medium tracking-wide text-red-500">
            {error === 'Insufficient balance' ? (
              <>
                Not enough funds.
-                <button
-                  className="ml-1 text-indigo-500 hover:underline hover:decoration-indigo-400"
-                  onClick={() => setAddFundsModalOpen(true)}
-                >
-                  Buy more?
-                </button>
-                <AddFundsModal
-                  open={addFundsModalOpen}
-                  setOpen={setAddFundsModalOpen}
-                />
+                <span className="ml-1 text-indigo-500">
+                  <SiteLink href="/add-funds">Buy more?</SiteLink>
+                </span>
              </>
            ) : (
              error
@ -147,7 +144,7 @@ export function BuyAmountInput(props: {

  return (
    <>
-      <Row className="items-center gap-4">
+      <Row className="gap-4">
        <AmountInput
          amount={amount}
          onChange={onAmountChange}
@ -159,23 +156,14 @@ export function BuyAmountInput(props: {
          inputRef={inputRef}
        />
        {showSlider && (
-          <Slider
-            min={0}
-            max={205}
+          <input
+            type="range"
+            min="0"
+            max="205"
            value={getRaw(amount ?? 0)}
-            onChange={(value) => onAmountChange(parseRaw(value as number))}
-            className="mx-4 !h-4 xl:hidden [&>.rc-slider-rail]:bg-gray-200 [&>.rc-slider-track]:bg-indigo-400 [&>.rc-slider-handle]:bg-indigo-400"
-            railStyle={{ height: 16, top: 0, left: 0 }}
-            trackStyle={{ height: 16, top: 0 }}
-            handleStyle={{
-              height: 32,
-              width: 32,
-              opacity: 1,
-              border: 'none',
-              boxShadow: 'none',
-              top: -2,
-            }}
-            step={5}
+            onChange={(e) => onAmountChange(parseRaw(parseInt(e.target.value)))}
+            className="range range-lg only-thumb z-40 my-auto align-middle xl:hidden"
+            step="5"
          />
        )}
      </Row>
--- a/web/components/analytics/charts.tsx
+++ b/web/components/analytics/charts.tsx
@ -0,0 +1,139 @@
+import { Point, ResponsiveLine } from '@nivo/line'
+import clsx from 'clsx'
+import { formatPercent } from 'common/util/format'
+import dayjs from 'dayjs'
+import { zip } from 'lodash'
+import { useWindowSize } from 'web/hooks/use-window-size'
+import { Col } from '../layout/col'
+
+export function DailyCountChart(props: {
+  startDate: number
+  dailyCounts: number[]
+  small?: boolean
+}) {
+  const { dailyCounts, startDate, small } = props
+  const { width } = useWindowSize()
+
+  const dates = dailyCounts.map((_, i) =>
+    dayjs(startDate).add(i, 'day').toDate()
+  )
+
+  const points = zip(dates, dailyCounts).map(([date, betCount]) => ({
+    x: date,
+    y: betCount,
+  }))
+  const data = [{ id: 'Count', data: points, color: '#11b981' }]
+
+  const bottomAxisTicks = width && width < 600 ? 6 : undefined
+
+  return (
+    <div
+      className={clsx(
+        'h-[250px] w-full overflow-hidden',
+        !small && 'md:h-[400px]'
+      )}
+    >
+      <ResponsiveLine
+        data={data}
+        yScale={{ type: 'linear', stacked: false }}
+        xScale={{
+          type: 'time',
+        }}
+        axisBottom={{
+          tickValues: bottomAxisTicks,
+          format: (date) => dayjs(date).format('MMM DD'),
+        }}
+        colors={{ datum: 'color' }}
+        pointSize={0}
+        pointBorderWidth={1}
+        pointBorderColor="#fff"
+        enableSlices="x"
+        enableGridX={!!width && width >= 800}
+        enableArea
+        margin={{ top: 20, right: 28, bottom: 22, left: 40 }}
+        sliceTooltip={({ slice }) => {
+          const point = slice.points[0]
+          return <Tooltip point={point} />
+        }}
+      />
+    </div>
+  )
+}
+
+export function DailyPercentChart(props: {
+  startDate: number
+  dailyPercent: number[]
+  small?: boolean
+  excludeFirstDays?: number
+}) {
+  const { dailyPercent, startDate, small, excludeFirstDays } = props
+  const { width } = useWindowSize()
+
+  const dates = dailyPercent.map((_, i) =>
+    dayjs(startDate).add(i, 'day').toDate()
+  )
+
+  const points = zip(dates, dailyPercent)
+    .map(([date, percent]) => ({
+      x: date,
+      y: percent,
+    }))
+    .slice(excludeFirstDays ?? 0)
+  const data = [{ id: 'Percent', data: points, color: '#11b981' }]
+
+  const bottomAxisTicks = width && width < 600 ? 6 : undefined
+
+  return (
+    <div
+      className={clsx(
+        'h-[250px] w-full overflow-hidden',
+        !small && 'md:h-[400px]'
+      )}
+    >
+      <ResponsiveLine
+        data={data}
+        yScale={{ type: 'linear', stacked: false }}
+        xScale={{
+          type: 'time',
+        }}
+        axisLeft={{
+          format: formatPercent,
+        }}
+        axisBottom={{
+          tickValues: bottomAxisTicks,
+          format: (date) => dayjs(date).format('MMM DD'),
+        }}
+        colors={{ datum: 'color' }}
+        pointSize={0}
+        pointBorderWidth={1}
+        pointBorderColor="#fff"
+        enableSlices="x"
+        enableGridX={!!width && width >= 800}
+        enableArea
+        margin={{ top: 20, right: 28, bottom: 22, left: 40 }}
+        sliceTooltip={({ slice }) => {
+          const point = slice.points[0]
+          return <Tooltip point={point} isPercent />
+        }}
+      />
+    </div>
+  )
+}
+
+function Tooltip(props: { point: Point; isPercent?: boolean }) {
+  const { point, isPercent } = props
+  return (
+    <Col className="border border-gray-300 bg-white py-2 px-3">
+      <div
+        className="pb-1"
+        style={{
+          color: point.serieColor,
+        }}
+      >
+        <strong>{point.serieId}</strong>{' '}
+        {isPercent ? formatPercent(+point.data.y) : Math.round(+point.data.y)}
+      </div>
+      <div>{dayjs(point.data.x).format('MMM DD')}</div>
+    </Col>
+  )
+}
--- a/web/components/answers/answer-bet-panel.tsx
+++ b/web/components/answers/answer-bet-panel.tsx
@ -126,10 +126,7 @@ export function AnswerBetPanel(props: {
        </div>

        {!isModal && (
-          <button
-            className="hover:bg-greyscale-2 rounded-full"
-            onClick={closePanel}
-          >
+          <button className="btn-ghost btn-circle" onClick={closePanel}>
            <XIcon
              className="mx-auto h-8 w-8 text-gray-500"
              aria-hidden="true"
@ -187,15 +184,16 @@ export function AnswerBetPanel(props: {
      <Spacer h={6} />
      {user ? (
        <WarningConfirmationButton
-          size="xl"
          marketType="freeResponse"
          amount={betAmount}
          warning={warning}
          onSubmit={submitBet}
          isSubmitting={isSubmitting}
          disabled={!!betDisabled}
-          color={'indigo'}
-          actionLabel="Buy"
+          openModalButtonClass={clsx(
+            'btn self-stretch',
+            betDisabled ? 'btn-disabled' : 'btn-primary'
+          )}
        />
      ) : (
        <BetSignUpPrompt />
--- a/web/components/answers/answer-item.tsx
+++ b/web/components/answers/answer-item.tsx
@ -10,7 +10,6 @@ import { formatPercent } from 'common/util/format'
 import { getDpmOutcomeProbability } from 'common/calculate-dpm'
 import { tradingAllowed } from 'web/lib/firebase/contracts'
 import { Linkify } from '../linkify'
-import { Input } from '../input'

 export function AnswerItem(props: {
  answer: Answer
@ -75,8 +74,8 @@ export function AnswerItem(props: {
      <Row className="items-center justify-end gap-4 self-end sm:self-start">
        {!wasResolvedTo &&
          (showChoice === 'checkbox' ? (
-            <Input
-              className="w-24 justify-self-end !text-2xl"
+            <input
+              className="input input-bordered w-24 justify-self-end text-2xl"
              type="number"
              placeholder={`${roundedProb}`}
              maxLength={9}
@ -93,15 +92,15 @@ export function AnswerItem(props: {
            <div
              className={clsx(
                'text-2xl',
-                tradingAllowed(contract) ? 'text-teal-500' : 'text-gray-500'
+                tradingAllowed(contract) ? 'text-green-500' : 'text-gray-500'
              )}
            >
              {probPercent}
            </div>
          ))}
        {showChoice ? (
-          <div className="flex flex-col py-1">
-            <label className="cursor-pointer gap-3 px-1 py-2">
+          <div className="form-control py-1">
+            <label className="label cursor-pointer gap-3">
              <span className="">Choose this answer</span>
              {showChoice === 'radio' && (
                <input
@ -144,7 +143,7 @@ export function AnswerItem(props: {
              <div
                className={clsx(
                  'text-xl',
-                  resolution === 'MKT' ? 'text-blue-700' : 'text-teal-600'
+                  resolution === 'MKT' ? 'text-blue-700' : 'text-green-700'
                )}
              >
                Chosen{' '}
--- a/web/components/answers/answer-resolve-panel.tsx
+++ b/web/components/answers/answer-resolve-panel.tsx
@ -10,7 +10,6 @@ import { ChooseCancelSelector } from '../yes-no-selector'
 import { ResolveConfirmationButton } from '../confirmation-button'
 import { removeUndefinedProps } from 'common/util/object'
 import { BETTOR, PAST_BETS } from 'common/user'
-import { Button } from '../button'

 export function AnswerResolvePanel(props: {
  isAdmin: boolean
@ -86,6 +85,17 @@ export function AnswerResolvePanel(props: {
    setIsSubmitting(false)
  }

+  const resolutionButtonClass =
+    resolveOption === 'CANCEL'
+      ? 'bg-yellow-400 hover:bg-yellow-500'
+      : resolveOption === 'CHOOSE' && answers.length
+      ? 'btn-primary'
+      : resolveOption === 'CHOOSE_MULTIPLE' &&
+        answers.length > 1 &&
+        answers.every((answer) => chosenAnswers[answer] > 0)
+      ? 'bg-blue-400 hover:bg-blue-500'
+      : 'btn-disabled'
+
  return (
    <Col className="gap-4 rounded">
      <Row className="justify-between">
@ -110,37 +120,20 @@ export function AnswerResolvePanel(props: {
          )}
        >
          {resolveOption && (
-            <Button
-              color="gray-white"
+            <button
+              className="btn btn-ghost"
              onClick={() => {
                setResolveOption(undefined)
              }}
            >
              Clear
-            </Button>
+            </button>
          )}
-
          <ResolveConfirmationButton
-            color={
-              resolveOption === 'CANCEL'
-                ? 'yellow'
-                : resolveOption === 'CHOOSE' && answers.length
-                ? 'green'
-                : resolveOption === 'CHOOSE_MULTIPLE' &&
-                  answers.length > 1 &&
-                  answers.every((answer) => chosenAnswers[answer] > 0)
-                ? 'blue'
-                : 'indigo'
-            }
-            disabled={
-              !resolveOption ||
-              (resolveOption === 'CHOOSE' && !answers.length) ||
-              (resolveOption === 'CHOOSE_MULTIPLE' &&
-                (!(answers.length > 1) ||
-                  !answers.every((answer) => chosenAnswers[answer] > 0)))
-            }
            onResolve={onResolve}
            isSubmitting={isSubmitting}
+            openModalButtonClass={resolutionButtonClass}
+            submitButtonClass={resolutionButtonClass}
          />
        </Row>
      </Col>
--- a/Show More
+++ b/Show More