ci(release): publish latest release

Author: hello-happy-puppy

RELEASE

@@ -1,6 +1,6 @@
 IPFS hash of the deployment:
-- CIDv0: `Qma941FXDbQqHNpD7hkUYG1PrK3s6vmuimRLL9M8p5tm3Z`
-- CIDv1: `bafybeifpkoosgylgtfnzobmelsuj6wjfwlpzwy5mg2jilplofd5tmxtfdq`
+- CIDv0: `QmWxnggRwg77vUtPTytonsniRaCU2EHrNmpSdLqFuoQMvp`
+- CIDv1: `bafybeiead5wcaopistyt53f5zrvgb7wkxfnzssqo2vuzu37pw4z62drqpe`
 
 The latest release is always mirrored at [app.uniswap.org](https://app.uniswap.org).
 
@@ -10,5 +10,5 @@ You can also access the Uniswap Interface from an IPFS gateway.
 Your Uniswap settings are never remembered across different URLs.
 
 IPFS gateways:
-- https://bafybeifpkoosgylgtfnzobmelsuj6wjfwlpzwy5mg2jilplofd5tmxtfdq.ipfs.dweb.link/
-- [ipfs://Qma941FXDbQqHNpD7hkUYG1PrK3s6vmuimRLL9M8p5tm3Z/](ipfs://Qma941FXDbQqHNpD7hkUYG1PrK3s6vmuimRLL9M8p5tm3Z/)
+- https://bafybeiead5wcaopistyt53f5zrvgb7wkxfnzssqo2vuzu37pw4z62drqpe.ipfs.dweb.link/
+- [ipfs://QmWxnggRwg77vUtPTytonsniRaCU2EHrNmpSdLqFuoQMvp/](ipfs://QmWxnggRwg77vUtPTytonsniRaCU2EHrNmpSdLqFuoQMvp/)

VERSION

@@ -1 +1 @@
-web/5.151.3
+web/5.151.4

apps/web/src/pages/Liquidity/CreateAuction/components/AuctionSupplySection.tsx

@@ -6,6 +6,7 @@ import { AuctionSupplySelector } from '~/pages/Liquidity/CreateAuction/component
 interface AuctionSupplySectionProps {
   auctionSupplyAmount: CurrencyAmount<Currency>
   tokenTotalSupply: CurrencyAmount<Currency>
+  maxAuctionSupplyAmount: CurrencyAmount<Currency>
   minAuctionSupplyAmount: CurrencyAmount<Currency>
   tokenSymbol: string
   onSelectAuctionSupplyPercent: (percent: number) => void
@@ -15,6 +16,7 @@ interface AuctionSupplySectionProps {
 export function AuctionSupplySection({
   auctionSupplyAmount,
   tokenTotalSupply,
+  maxAuctionSupplyAmount,
   minAuctionSupplyAmount,
   tokenSymbol,
   onSelectAuctionSupplyPercent,
@@ -35,6 +37,7 @@ export function AuctionSupplySection({
       <AuctionSupplySelector
         auctionSupplyAmount={auctionSupplyAmount}
         tokenTotalSupply={tokenTotalSupply}
+        maxAuctionSupplyAmount={maxAuctionSupplyAmount}
         minAuctionSupplyAmount={minAuctionSupplyAmount}
         tokenSymbol={tokenSymbol}
         onSelectPercent={onSelectAuctionSupplyPercent}

apps/web/src/pages/Liquidity/CreateAuction/components/AuctionSupplySelector.tsx

@@ -40,6 +40,12 @@ function parseSuffixedAmount(input: string, currency: Currency): CurrencyAmount<
 interface AuctionSupplySelectorProps {
   auctionSupplyAmount: CurrencyAmount<Currency>
   tokenTotalSupply: CurrencyAmount<Currency>
+  /**
+   * Ceiling the deposit is clamped to. For a new token this is the full minted supply; for an
+   * existing token it is the connected wallet's held balance (what the auction can actually pull).
+   * The "Max" preset and percent presets are computed against this, not the total supply.
+   */
+  maxAuctionSupplyAmount: CurrencyAmount<Currency>
   /** Smallest deposit whose sold/LP split keeps both legs at >= 1 base unit; clamped to on blur. */
   minAuctionSupplyAmount: CurrencyAmount<Currency>
   tokenSymbol: string
@@ -50,6 +56,7 @@ interface AuctionSupplySelectorProps {
 export function AuctionSupplySelector({
   auctionSupplyAmount,
   tokenTotalSupply,
+  maxAuctionSupplyAmount,
   minAuctionSupplyAmount,
   tokenSymbol,
   onSelectPercent,
@@ -93,11 +100,11 @@ export function AuctionSupplySelector({
       if (!parsed) {
         return
       }
-      // Live-update with exact amount; cap to total supply so the store stays valid
-      const capped = parsed.greaterThan(tokenTotalSupply) ? tokenTotalSupply : parsed
+      // Live-update with exact amount; cap to the deposit ceiling so the store stays valid
+      const capped = parsed.greaterThan(maxAuctionSupplyAmount) ? maxAuctionSupplyAmount : parsed
       onAmountChange(capped)
     },
-    [currency, tokenTotalSupply, onAmountChange],
+    [currency, maxAuctionSupplyAmount, onAmountChange],
   )
 
   const {
@@ -115,7 +122,7 @@ export function AuctionSupplySelector({
     () => (isFocused ? parseSuffixedAmount(rawInput, currency) : null),
     [isFocused, rawInput, currency],
   )
-  const exceedsTotalSupply = parsedAmount !== null && parsedAmount.greaterThan(tokenTotalSupply)
+  const exceedsMax = parsedAmount !== null && parsedAmount.greaterThan(maxAuctionSupplyAmount)
 
   const handleFocus = useCallback(() => {
     setIsFocused(true)
@@ -132,17 +139,17 @@ export function AuctionSupplySelector({
       return
     }
 
-    // Clamp into [min, totalSupply] on blur: the lower bound keeps the sold/LP split from
-    // rounding a leg to zero base units (a degenerate auction that divides by zero in the
-    // percent math); the upper bound keeps the deposit within the available supply. Raise to
-    // the min first, then cap at total supply, so the supply ceiling always wins — in the
-    // pathological case where min > totalSupply (a token with fewer base units than the
-    // minimum two-leg deposit) the result never exceeds what exists, and the step's own
-    // validation disables Continue since the deposit stays below the minimum.
+    // Clamp into [min, max] on blur: the lower bound keeps the sold/LP split from rounding a leg to
+    // zero base units (a degenerate auction that divides by zero in the percent math); the upper
+    // bound is the deposit ceiling (full supply for a new token, wallet balance for an existing one).
+    // Raise to the min first, then cap at the ceiling, so the ceiling always wins — in the
+    // pathological case where min > max (a token with fewer base units than the minimum two-leg
+    // deposit, or a wallet holding too little) the result never exceeds the ceiling, and the step's
+    // own validation disables Continue since the deposit stays below the minimum.
     const raised = parsed.lessThan(minAuctionSupplyAmount) ? minAuctionSupplyAmount : parsed
-    const clamped = raised.greaterThan(tokenTotalSupply) ? tokenTotalSupply : raised
+    const clamped = raised.greaterThan(maxAuctionSupplyAmount) ? maxAuctionSupplyAmount : raised
     onAmountChange(clamped)
-  }, [rawInput, currency, tokenTotalSupply, minAuctionSupplyAmount, onAmountChange])
+  }, [rawInput, currency, maxAuctionSupplyAmount, minAuctionSupplyAmount, onAmountChange])
 
   const trace = useTrace()
   const handleSelectPercent = useCallback(
@@ -195,7 +202,7 @@ export function AuctionSupplySelector({
               fontSize={fonts.heading3.fontSize}
               lineHeight={fonts.heading3.lineHeight}
               fontWeight={fonts.heading3.fontWeight}
-              color={exceedsTotalSupply ? '$statusCritical' : '$neutral1'}
+              color={exceedsMax ? '$statusCritical' : '$neutral1'}
               backgroundColor="$transparent"
             />
           </Trace>
@@ -237,13 +244,13 @@ export function AuctionSupplySelector({
             <PercentButton
               key={pillPercent}
               label={`${pillPercent}%`}
-              isActive={auctionSupplyAmount.equalTo(percentOfAmount(tokenTotalSupply, pillPercent))}
+              isActive={auctionSupplyAmount.equalTo(percentOfAmount(maxAuctionSupplyAmount, pillPercent))}
               onPress={handleSelectPercent.bind(null, pillPercent)}
             />
           ))}
           <PercentButton
             label={t('common.max')}
-            isActive={auctionSupplyAmount.equalTo(tokenTotalSupply)}
+            isActive={auctionSupplyAmount.equalTo(maxAuctionSupplyAmount)}
             onPress={handleSelectPercent.bind(null, 100)}
           />
         </Flex>

apps/web/src/pages/Liquidity/CreateAuction/components/LaunchAuctionErrorModal.tsx

@@ -4,7 +4,10 @@ import { Dialog } from 'uniswap/src/components/dialog/Dialog'
 import { UniswapHelpUrls } from 'uniswap/src/constants/urls'
 import { ModalName } from 'uniswap/src/features/telemetry/constants'
 import { getCreateAuctionErrorMessage } from '~/pages/Liquidity/CreateAuction/getCreateAuctionErrorMessage'
-import { AuctionStartTimePassedError } from '~/pages/Liquidity/CreateAuction/hooks/useCreateAuctionSubmit'
+import {
+  AuctionInsufficientBalanceError,
+  AuctionStartTimePassedError,
+} from '~/pages/Liquidity/CreateAuction/hooks/useCreateAuctionSubmit'
 
 interface LaunchAuctionErrorModalProps {
   isOpen: boolean
@@ -27,16 +30,16 @@ export function LaunchAuctionErrorModal({
   // Known pre-submission errors get specific, actionable copy. Backend input-validation failures
   // (e.g. an unsupported fee tier) carry a meaningful reason worth surfacing verbatim; everything
   // else falls back to a generic, localized reason since raw backend messages aren't user-friendly.
-  // Verbatim backend reasons render on their own line; the generic reason stays inline.
   const validationReason = getCreateAuctionErrorMessage(error)
   const genericReason = t('toucan.createAuction.launchError.genericReason')
   const subtext =
     error instanceof AuctionStartTimePassedError
       ? t('toucan.createAuction.launchError.startTimePassed', { tokenSymbol })
-      : t('toucan.createAuction.launchError.description', {
-          tokenSymbol,
-          reason: validationReason ? `\n${validationReason}` : genericReason,
-        })
+      : error instanceof AuctionInsufficientBalanceError
+        ? t('toucan.createAuction.launchError.insufficientBalance', { tokenSymbol })
+        : validationReason
+          ? t('toucan.createAuction.launchError.withReason', { tokenSymbol, reason: validationReason })
+          : t('toucan.createAuction.launchError.description', { tokenSymbol, reason: genericReason })
 
   return (
     <Dialog

apps/web/src/pages/Liquidity/CreateAuction/hooks/useCreateAuctionSubmit.test.ts

@@ -1,12 +1,17 @@
 import { act, renderHook } from '@testing-library/react'
+import { CurrencyAmount, Token } from '@uniswap/sdk-core'
+import { UniverseChainId } from 'uniswap/src/features/chains/types'
+import type { CurrencyInfo } from 'uniswap/src/features/dataApi/types'
 import { AuctionEventName } from 'uniswap/src/features/telemetry/constants'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { zeroAddress } from '~/chains'
 import {
+  AuctionInsufficientBalanceError,
   AuctionStartTimePassedError,
   useCreateAuctionSubmit,
 } from '~/pages/Liquidity/CreateAuction/hooks/useCreateAuctionSubmit'
 import { createCreateAuctionStore } from '~/pages/Liquidity/CreateAuction/store/createCreateAuctionStore'
+import { TokenMode } from '~/pages/Liquidity/CreateAuction/types'
 import { MS_PER_DAY } from '~/pages/Liquidity/CreateAuction/utils/duration'
 
 const WALLET = '0xF570F45f598fD48AF83FABD692629a2caFe899ec'
@@ -58,6 +63,37 @@ function buildableParams(overrides: Partial<Params> = {}): Params {
   }
 }
 
+const UNI_ADDRESS = '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984'
+
+/** Buildable params for an existing token (UNI) with a configured deposit of `depositRaw` base units. */
+function existingTokenParams(depositRaw: string, overrides: Partial<Params> = {}): Params {
+  const store = createCreateAuctionStore()
+  const { actions } = store.getState()
+  const uni = new Token(UniverseChainId.Mainnet, UNI_ADDRESS, 18, 'UNI', 'Uniswap')
+  actions.setTokenForm({
+    mode: TokenMode.EXISTING,
+    existingTokenCurrencyInfo: { currency: uni } as CurrencyInfo,
+    description: '',
+    xProfile: '',
+    websiteLink: '',
+    totalSupply: CurrencyAmount.fromRawAmount(uni, '1000000000000000000000000000'),
+  })
+  actions.commitTokenFormAndAdvance()
+  actions.setStartTime(new Date(Date.now() + MS_PER_DAY))
+  actions.setEndTime(new Date(Date.now() + 4 * MS_PER_DAY))
+  actions.setFloorPrice('0.1')
+  actions.setAuctionConfig({ auctionSupplyAmount: CurrencyAmount.fromRawAmount(uni, depositRaw) })
+  const { tokenForm, configureAuction, customizePool } = store.getState()
+  return {
+    tokenForm,
+    configureAuction,
+    customizePool,
+    walletAddress: WALLET,
+    currencyAddress: zeroAddress,
+    ...overrides,
+  }
+}
+
 beforeEach(() => {
   mockMutateAsync.mockReset()
   mockValidate.mockReset()
@@ -130,6 +166,21 @@ describe('useCreateAuctionSubmit', () => {
     expect(result.current.error).toBeInstanceOf(AuctionStartTimePassedError)
   })
 
+  it('errors without calling the mutation when the deposit exceeds the wallet balance', async () => {
+    // Configured to deposit 1000 base units but the wallet only holds 600.
+    const params = existingTokenParams('1000', { existingTokenWalletBalanceRaw: 600n })
+    const { result } = renderHook(() => useCreateAuctionSubmit(params))
+
+    let returned: Awaited<ReturnType<typeof result.current.onLaunch>>
+    await act(async () => {
+      returned = await result.current.onLaunch()
+    })
+
+    expect(returned).toBeUndefined()
+    expect(mockMutateAsync).not.toHaveBeenCalled()
+    expect(result.current.error).toBeInstanceOf(AuctionInsufficientBalanceError)
+  })
+
   it('returns the validated result on success', async () => {
     const tx = { to: '0xto', from: WALLET, data: '0x', value: '0x0', chainId: 1 }
     mockMutateAsync.mockResolvedValue({

apps/web/src/pages/Liquidity/CreateAuction/hooks/useCreateAuctionSubmit.ts

@@ -26,6 +26,18 @@ export class AuctionStartTimePassedError extends Error {
   }
 }
 
+/**
+ * Thrown at launch time when the wallet holds fewer tokens than the configured deposit — the auction
+ * pulls the deposit from the wallet, so the backend would reject it. Mapped to actionable copy in
+ * `LaunchAuctionErrorModal`.
+ */
+export class AuctionInsufficientBalanceError extends Error {
+  constructor() {
+    super('Wallet token balance is insufficient to fund the auction')
+    this.name = 'AuctionInsufficientBalanceError'
+  }
+}
+
 export interface CreateAuctionSubmitResult {
   predictedTokenAddress: string
   predictedAuctionAddress: string
@@ -45,6 +57,12 @@ interface UseCreateAuctionSubmitParams {
   currencyAddress: string | undefined
   /** From X OAuth / VerifyXCallback when the creator linked their handle. */
   xVerificationToken?: string | null
+  /**
+   * Existing-token only: the connected wallet's on-chain balance in base units. Used for the
+   * build-time insufficient-balance check so a deposit larger than the held balance can't hit the
+   * backend's "insufficient balance" rejection.
+   */
+  existingTokenWalletBalanceRaw?: bigint
   /**
    * Builds `Auction Create Failed` properties. Called by this hook at pre-submission failure points
    * (`build_request` for local validation, `create_auction_request` when the endpoint throws).
@@ -119,6 +137,7 @@ export function useCreateAuctionSubmit(params: UseCreateAuctionSubmitParams): Us
     walletAddress,
     currencyAddress,
     xVerificationToken,
+    existingTokenWalletBalanceRaw,
     getCreateFailedProperties,
   } = params
   const createAuctionMutation = useCreateAuctionMutation()
@@ -153,6 +172,19 @@ export function useCreateAuctionSubmit(params: UseCreateAuctionSubmitParams): Us
       return undefined
     }
 
+    // Existing tokens pull the deposit from the wallet, so a deposit larger than the held balance
+    // can't be funded — fail here instead of letting the backend reject it.
+    if (
+      existingTokenWalletBalanceRaw !== undefined &&
+      configureAuction.committed &&
+      BigInt(configureAuction.committed.auctionSupplyAmount.quotient.toString()) > existingTokenWalletBalanceRaw
+    ) {
+      const err = new AuctionInsufficientBalanceError()
+      setError(err)
+      reportAuctionCreateFailed({ getCreateFailedProperties, failedStep: 'build_request', error: err, diagnostics })
+      return undefined
+    }
+
     const request = buildCreateAuctionRequest({
       tokenForm,
       configureAuction,

apps/web/src/pages/Liquidity/CreateAuction/hooks/useExistingTokenWalletBalance.ts

@@ -0,0 +1,41 @@
+import { type Currency, CurrencyAmount, type Token } from '@uniswap/sdk-core'
+import { useMemo } from 'react'
+import { Platform } from 'uniswap/src/features/platforms/types/Platform'
+import { useReadContract } from 'wagmi'
+import { erc20Abi } from '~/chains'
+import { useActiveAddress } from '~/features/accounts/store/hooks'
+import { assume0xAddress } from '~/utils/wagmi'
+
+interface UseExistingTokenWalletBalanceResult {
+  balance: CurrencyAmount<Token> | undefined
+  isLoading: boolean
+  isError: boolean
+}
+
+/**
+ * Reads the connected EVM wallet's on-chain balance of the given token, on the token's own chain.
+ *
+ * Mirrors {@link useTotalSupply} (a direct wagmi `balanceOf` read keyed on the token's chainId)
+ * rather than `useCurrencyBalance`, which gates on the wallet's currently-connected chain — an
+ * existing auction token can live on a chain the wallet isn't actively connected to.
+ */
+export function useExistingTokenWalletBalance(token?: Currency): UseExistingTokenWalletBalanceResult {
+  const account = useActiveAddress(Platform.EVM)
+  const tokenAddress = token?.isToken ? assume0xAddress(token.address) : undefined
+
+  const { data, isLoading, isError } = useReadContract({
+    address: tokenAddress,
+    chainId: token?.chainId,
+    abi: erc20Abi,
+    functionName: 'balanceOf',
+    args: account ? [assume0xAddress(account)] : undefined,
+    query: { enabled: !!tokenAddress && !!account },
+  })
+
+  const balance = useMemo(
+    () => (token?.isToken && data !== undefined ? CurrencyAmount.fromRawAmount(token, data.toString()) : undefined),
+    [token, data],
+  )
+
+  return { balance, isLoading, isError }
+}