ci(release): publish latest release

Author: hello-happy-puppy

RELEASE

@@ -1,6 +1,6 @@
 IPFS hash of the deployment:
-- CIDv0: `QmNftmD2jYM2MD7TjHfd7wmu3tgBvXJCra1Z1z9xEYtrLA`
-- CIDv1: `bafybeiae5xwpty5fbnkusf3g5twy3dpy2bjgjemsw6jvd4wehdyn46xbam`
+- CIDv0: `QmPc7bbKd3n3rAv4VUE224YoCvYrRLxxWH9Uc8QswwMvpn`
+- CIDv1: `bafybeias2hgrfu22qvwpfn2pv56qeovr2nnnywreibcs2rzlpch2mipkq4`
 
 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://bafybeiae5xwpty5fbnkusf3g5twy3dpy2bjgjemsw6jvd4wehdyn46xbam.ipfs.dweb.link/
-- [ipfs://QmNftmD2jYM2MD7TjHfd7wmu3tgBvXJCra1Z1z9xEYtrLA/](ipfs://QmNftmD2jYM2MD7TjHfd7wmu3tgBvXJCra1Z1z9xEYtrLA/)
+- https://bafybeias2hgrfu22qvwpfn2pv56qeovr2nnnywreibcs2rzlpch2mipkq4.ipfs.dweb.link/
+- [ipfs://QmPc7bbKd3n3rAv4VUE224YoCvYrRLxxWH9Uc8QswwMvpn/](ipfs://QmPc7bbKd3n3rAv4VUE224YoCvYrRLxxWH9Uc8QswwMvpn/)

VERSION

@@ -1 +1 @@
-web/5.154.3
+web/5.154.4

apps/web/src/features/Toucan/Auction/hooks/useAuctionLiquidityLock.test.ts

@@ -12,7 +12,10 @@ import {
 import { formatTimestampToDate } from '~/features/Toucan/Auction/utils/formatting'
 
 const mockUseStatsBannerData = vi.fn()
-const mockStoreState = { auctionDetails: null as AuctionDetails | null }
+const mockStoreState = {
+  auctionDetails: null as AuctionDetails | null,
+  currentBlockNumber: undefined as number | undefined,
+}
 
 vi.mock('~/features/Toucan/Auction/hooks/useStatsBannerData', () => ({
   useStatsBannerData: () => mockUseStatsBannerData(),
@@ -91,6 +94,7 @@ describe('useAuctionLiquidityLock', () => {
     vi.clearAllMocks()
     mockStatsBanner()
     mockStoreState.auctionDetails = null
+    mockStoreState.currentBlockNumber = undefined
   })
 
   it('returns not-locked defaults when the auction has no lock info', () => {
@@ -149,6 +153,124 @@ describe('useAuctionLiquidityLock', () => {
     expect(result.current.unlockDateFormatted).toBe(formatTimestampToDate(UNLOCK_TIMESTAMP))
   })
 
+  it('reads an expired timelock as never-locked', () => {
+    mockStoreState.currentBlockNumber = 40000001
+    mockStoreState.auctionDetails = buildAuctionDetails({
+      poolOwner: POOL_OWNER,
+      liquidityLock: {
+        lockRecipient: LOCK_RECIPIENT,
+        lockMode: 1,
+        unlockBlock: '40000000',
+        lpOperator: LP_OPERATOR,
+      },
+    })
+
+    const { result } = renderHook(() => useAuctionLiquidityLock())
+
+    // Lock-status indicators clear: no unlock date, LP owner falls back to the pool owner
+    expect(result.current.isLocked).toBe(false)
+    expect(result.current.isBuybackEnabled).toBe(false)
+    expect(result.current.isFeesForwarder).toBe(false)
+    expect(result.current.unlockTimestamp).toBeUndefined()
+    expect(result.current.unlockDateFormatted).toBeUndefined()
+    expect(result.current.lpOwner).toBe(POOL_OWNER)
+  })
+
+  it('keeps the buyback-burn stat and pill after the lock expires', () => {
+    mockStoreState.currentBlockNumber = 40000001
+    mockStoreState.auctionDetails = buildAuctionDetails({
+      poolOwner: POOL_OWNER,
+      liquidityLock: {
+        lockRecipient: LOCK_RECIPIENT,
+        lockMode: 3,
+        unlockBlock: '40000000',
+        lpOperator: LP_OPERATOR,
+        totalTokensBurned: BURNED_RAW,
+      },
+    })
+
+    const { result } = renderHook(() => useAuctionLiquidityLock())
+
+    // Lock-status indicators clear on expiry...
+    expect(result.current.isLocked).toBe(false)
+    expect(result.current.unlockDateFormatted).toBeUndefined()
+    expect(result.current.lpOwner).toBe(POOL_OWNER)
+    // ...but buyback & burn is a permanent characteristic and must persist
+    expect(result.current.isBuybackEnabled).toBe(true)
+    expect(result.current.hasBurnedTokens).toBe(true)
+    expect(result.current.burnedAmountFormatted).toBe('1.25M TCAN')
+    expect(result.current.burnedUsdFormatted).toBe('$187500000')
+  })
+
+  it('shows no buyback stat for a never-locked auction', () => {
+    mockStoreState.auctionDetails = buildAuctionDetails({ poolOwner: POOL_OWNER })
+
+    const { result } = renderHook(() => useAuctionLiquidityLock())
+
+    expect(result.current.isBuybackEnabled).toBe(false)
+    expect(result.current.hasBurnedTokens).toBe(false)
+    expect(result.current.burnedAmountFormatted).toBeUndefined()
+  })
+
+  it('stays locked when the unlock block has not been reached yet', () => {
+    mockStoreState.currentBlockNumber = 39999999
+    mockStoreState.auctionDetails = buildAuctionDetails({
+      poolOwner: POOL_OWNER,
+      liquidityLock: {
+        lockRecipient: LOCK_RECIPIENT,
+        lockMode: 1,
+        unlockBlock: '40000000',
+        lpOperator: LP_OPERATOR,
+      },
+    })
+
+    const { result } = renderHook(() => useAuctionLiquidityLock())
+
+    expect(result.current.isLocked).toBe(true)
+    expect(result.current.lockMode).toBe(AuctionLockMode.Timelock)
+    expect(result.current.lpOwner).toBe(LP_OPERATOR)
+    expect(result.current.unlockDateFormatted).toBe(formatTimestampToDate(UNLOCK_TIMESTAMP))
+  })
+
+  it('keeps a permanent lock locked regardless of the current block', () => {
+    mockStoreState.currentBlockNumber = 260000000001
+    mockStoreState.auctionDetails = buildAuctionDetails({
+      liquidityLock: {
+        lockRecipient: LOCK_RECIPIENT,
+        lockMode: 1,
+        unlockBlock: '260000000000',
+        lpOperator: LP_OPERATOR,
+        lockedForever: true,
+      },
+    })
+
+    const { result } = renderHook(() => useAuctionLiquidityLock())
+
+    expect(result.current.isLocked).toBe(true)
+    expect(result.current.isPermanentlyLocked).toBe(true)
+    expect(result.current.lockMode).toBe(AuctionLockMode.Timelock)
+    expect(result.current.lpOwner).toBe(LP_OPERATOR)
+  })
+
+  it('stays locked while the current block is still loading (no flash-off)', () => {
+    mockStoreState.currentBlockNumber = undefined
+    mockStoreState.auctionDetails = buildAuctionDetails({
+      poolOwner: POOL_OWNER,
+      liquidityLock: {
+        lockRecipient: LOCK_RECIPIENT,
+        lockMode: 1,
+        unlockBlock: '40000000',
+        lpOperator: LP_OPERATOR,
+      },
+    })
+
+    const { result } = renderHook(() => useAuctionLiquidityLock())
+
+    expect(result.current.isLocked).toBe(true)
+    expect(result.current.lockMode).toBe(AuctionLockMode.Timelock)
+    expect(result.current.lpOwner).toBe(LP_OPERATOR)
+  })
+
   it('reads a burn lock as permanently locked with no unlock date or LP owner', () => {
     mockStoreState.auctionDetails = buildAuctionDetails({
       poolOwner: POOL_OWNER,

apps/web/src/features/Toucan/Auction/hooks/useAuctionLiquidityLock.ts

@@ -17,9 +17,15 @@ export interface AuctionLiquidityLockData {
    * timelocks (`locked_forever` on the wire). Render "Forever" instead of an unlock date.
    */
   isPermanentlyLocked: boolean
-  /** Lock mode — undefined when not locked or the mode is unrecognized */
+  /**
+   * Lock mode from the raw lock data — undefined only when there is no lock or the mode is
+   * unrecognized. Independent of expiry (buyback-burn characteristics persist after a lock expires).
+   */
   lockMode: AuctionLockMode | undefined
-  /** True when the lock is a buyback & burn recipient. All buyback UI must be hidden when false. */
+  /**
+   * True when the lock is a buyback & burn recipient. Independent of expiry — the burn is
+   * permanent, so this stays true after a lock unlocks. All buyback UI must be hidden when false.
+   */
   isBuybackEnabled: boolean
   /** True when the lock is a fees-forwarder recipient */
   isFeesForwarder: boolean
@@ -76,6 +82,36 @@ function parseBigIntOrUndefined(value: string | number | bigint | undefined): bi
   }
 }
 
+/**
+ * A lock reads as active only while its unlock block is still in the future. Compare block
+ * numbers against `currentBlockNumber` — never the estimated unlock date, which drifts.
+ * `lockedForever` locks (burn / legacy max-int sentinel) never expire; any finite-unlockBlock
+ * lock — including buyback-burn — expires once the block is reached. While `currentBlockNumber`
+ * is undefined (still loading) the lock stays active to avoid a flash-off of the indicators.
+ */
+function resolveIsLocked({
+  hasLockRecipient,
+  isPermanentlyLocked,
+  unlockBlock,
+  currentBlockNumber,
+}: {
+  hasLockRecipient: boolean
+  isPermanentlyLocked: boolean
+  unlockBlock: bigint | undefined
+  currentBlockNumber: number | undefined
+}): boolean {
+  if (isPermanentlyLocked) {
+    return true
+  }
+  if (!hasLockRecipient) {
+    return false
+  }
+  if (unlockBlock === undefined || currentBlockNumber === undefined) {
+    return true
+  }
+  return BigInt(currentBlockNumber) < unlockBlock
+}
+
 /**
  * Derives display state for an auction's liquidity lock (timelock / fees-forwarder /
  * buyback & burn) from `GetAuction` data.
@@ -93,27 +129,43 @@ export function useAuctionLiquidityLock(): AuctionLiquidityLockData {
   const { clearingPriceDecimal, bidTokenInfo } = useStatsBannerData()
 
   const auctionDetails = useAuctionStore((state) => state.auctionDetails)
+  const currentBlockNumber = useAuctionStore((state) => state.currentBlockNumber)
 
   const lock = auctionDetails?.liquidityLock
   // Burn-mode locks and legacy max-int "Permanent" timelocks are served with `lockedForever`
   const isPermanentlyLocked = Boolean(lock?.lockedForever)
-  const isLocked = Boolean(lock?.lockRecipient) || isPermanentlyLocked
-  const lockMode = isLocked ? parseLockMode(lock?.lockMode) : undefined
+
+  // An expired lock reads as never-locked (see resolveIsLocked), so the lock-status indicators —
+  // chip, lock icon, "LP locked until", lpOwner — clear on expiry. Buyback-burn UI is derived
+  // separately below and intentionally survives expiry.
+  const unlockBlockBigInt = parseBigIntOrUndefined(lock?.unlockBlock)
+  const isLocked = resolveIsLocked({
+    hasLockRecipient: Boolean(lock?.lockRecipient),
+    isPermanentlyLocked,
+    unlockBlock: unlockBlockBigInt,
+    currentBlockNumber,
+  })
+
+  // Buyback & burn is a permanent token characteristic, not a lock-active state, so its mode and
+  // burned totals must survive lock expiry — derive them from the raw lock mode, never from the
+  // expiry-aware isLocked. Fees-forwarding, by contrast, stops once the LP unlocks (see feeRecipient).
+  const lockMode = parseLockMode(lock?.lockMode)
   const isBuybackEnabled = lockMode === AuctionLockMode.BuybackBurn
   const isFeesForwarder = lockMode === AuctionLockMode.FeesForwarder
 
   // Backend serves the unlock block only — estimate the calendar date the same way the
   // auction countdown estimates future blocks. A permanent lock has no meaningful unlock
   // block (0 for burn), so it must never feed the estimator.
-  const unlockBlock = isLocked && !isPermanentlyLocked ? parseBigIntOrUndefined(lock?.unlockBlock) : undefined
+  const unlockBlock = isLocked && !isPermanentlyLocked ? unlockBlockBigInt : undefined
   const unlockTimestamp = useBlockTimestamp({
     chainId: auctionDetails?.chainId,
     blockNumber: unlockBlock === undefined ? undefined : Number(unlockBlock),
   })
   const unlockDateFormatted = unlockTimestamp === undefined ? undefined : formatTimestampToDate(unlockTimestamp)
 
   const lpOwner = (isLocked ? lock?.lpOperator : auctionDetails?.poolOwner) || undefined
-  const feeRecipient = (isFeesForwarder ? lock?.feeRecipient : undefined) || undefined
+  // Fee forwarding is only meaningful while the LP is actually locked — hide it once expired
+  const feeRecipient = (isLocked && isFeesForwarder ? lock?.feeRecipient : undefined) || undefined
 
   const auctionTokenDecimals = getAuctionTokenDecimals(auctionDetails?.token)
   const auctionTokenSymbol = auctionDetails?.token?.currency.symbol ?? auctionDetails?.tokenSymbol