From 26ae84cef1d9e7f4e07ad155a0adc06c3e24c2d2 Mon Sep 17 00:00:00 2001
From: Rick Staa <rick.staa@outlook.com>
Date: Tue, 21 Jul 2026 11:41:27 +0200
Subject: [PATCH 1/8] fix: compare LPT allowance and balance in wei

/api/account-balance returns balance and allowance in wei, but the delegating
widget compared them against the human-readable LPT input. Both checks were
true for any realistic amount, so wallets holding a partial allowance never
saw the approve flow, the bondWithHint simulation reverted, and the Delegate
button became a silent no-op.

Compare in wei with BigInt, and disable Delegate while the simulation has no
config so a failed simulation cannot present as a working button.

Fixes #737

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 components/DelegatingWidget/Delegate.tsx | 25 +++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/components/DelegatingWidget/Delegate.tsx b/components/DelegatingWidget/Delegate.tsx
index 272f3b44..bd9ad5ec 100644
--- a/components/DelegatingWidget/Delegate.tsx
+++ b/components/DelegatingWidget/Delegate.tsx
@@ -167,19 +167,21 @@ const Delegate = ({
   const [approvalSubmitted, setApprovalSubmitted] = useState<boolean>(false);
 
   const amountIsNonEmpty = useMemo(() => amount, [amount]);
+  // `tokenBalance` and `transferAllowance` are wei, so compare in wei.
+  const amountWei = useMemo(() => {
+    try {
+      return amount ? parseEther(amount) : BigInt(0);
+    } catch {
+      return BigInt(0);
+    }
+  }, [amount]);
   const sufficientBalance = useMemo(
-    () =>
-      amountIsNonEmpty &&
-      parseFloat(amount) > 0 &&
-      Number(tokenBalance) >= amount,
-    [amount, amountIsNonEmpty, tokenBalance]
+    () => amountWei > BigInt(0) && BigInt(tokenBalance ?? 0) >= amountWei,
+    [amountWei, tokenBalance]
   );
   const sufficientTransferAllowance = useMemo(
-    () =>
-      amountIsNonEmpty &&
-      Number(transferAllowance) > 0 &&
-      Number(transferAllowance) >= amount,
-    [amount, amountIsNonEmpty, transferAllowance]
+    () => amountWei > BigInt(0) && BigInt(transferAllowance ?? 0) >= amountWei,
+    [amountWei, transferAllowance]
   );
 
   // show approve flow when: no error on inputs, not approved or pending, or approved in current session
@@ -260,7 +262,7 @@ const Delegate = ({
             </Button>
             <Button
               size="4"
-              disabled={!sufficientTransferAllowance}
+              disabled={!sufficientTransferAllowance || !bondWithHintConfig}
               variant="primary"
               onClick={onDelegate}
               css={{ width: "100%" }}
@@ -282,6 +284,7 @@ const Delegate = ({
       {cutChangeNotice}
       <Button
         size="4"
+        disabled={!bondWithHintConfig}
         onClick={onDelegate}
         variant="primary"
         css={{ width: "100%" }}

From ec8abc9fa739ec3aa27ef8593455c1bcb5b13ff6 Mon Sep 17 00:00:00 2001
From: Rick Staa <rick.staa@outlook.com>
Date: Tue, 21 Jul 2026 11:54:03 +0200
Subject: [PATCH 2/8] fix: parse the delegate amount once and re-simulate after
 approval

parseEther was called unguarded when building bondWithHintArgs, so a value
the number input accepts but viem rejects (e.g. `1e3`) threw during render and
took the widget down.

The bondWithHint simulation also ran before the allowance was in place, and
nothing re-runs a cached failure once the approval confirms, leaving Delegate
disabled until the amount was retyped or the page reloaded.

Parse the amount once, defensively, and reuse it for both the simulation args
and the balance/allowance checks. Gate the simulation on the allowance so it
first runs when it can succeed; a zero amount moves no tokens and needs none,
which keeps "Move Delegated Stake" working.

Keeps the amountWei > 0 guards: they match the previous parseFloat(amount) > 0
behaviour, and dropping them would enable Delegate for a zero-amount bond.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-Authored-By: Copilot <copilot-pull-request-reviewer[bot]@users.noreply.github.com>
Co-Authored-By: CodeRabbit <coderabbitai[bot]@users.noreply.github.com>
---
 components/DelegatingWidget/Delegate.tsx | 48 ++++++++++++++----------
 1 file changed, 29 insertions(+), 19 deletions(-)

diff --git a/components/DelegatingWidget/Delegate.tsx b/components/DelegatingWidget/Delegate.tsx
index bd9ad5ec..ea108ba8 100644
--- a/components/DelegatingWidget/Delegate.tsx
+++ b/components/DelegatingWidget/Delegate.tsx
@@ -124,8 +124,27 @@ const Delegate = ({
     }
   );
 
+  // `type="number"` accepts values `parseEther` rejects (e.g. `1e3`), so parse
+  // once, defensively, and reuse it everywhere.
+  const amountWei = useMemo(() => {
+    try {
+      return amount ? parseEther(amount) : BigInt(0);
+    } catch {
+      return BigInt(0);
+    }
+  }, [amount]);
+  // `tokenBalance` and `transferAllowance` are wei, so compare in wei.
+  const sufficientBalance = useMemo(
+    () => amountWei > BigInt(0) && BigInt(tokenBalance ?? 0) >= amountWei,
+    [amountWei, tokenBalance]
+  );
+  const sufficientTransferAllowance = useMemo(
+    () => amountWei > BigInt(0) && BigInt(transferAllowance ?? 0) >= amountWei,
+    [amountWei, transferAllowance]
+  );
+
   const bondWithHintArgs = {
-    amount: amount?.toString() ? parseEther(amount) : BigInt(0),
+    amount: amountWei,
     to,
     oldDelegateNewPosPrev,
     oldDelegateNewPosNext,
@@ -134,12 +153,19 @@ const Delegate = ({
   };
 
   const { data: bondWithHintConfig } = useSimulateContract({
-    query: { enabled: Boolean(to) },
+    // Simulating without the allowance in place reverts, and nothing re-runs a
+    // cached failure once the approval lands. Gating on the allowance means the
+    // simulation first runs when it can succeed. A zero amount moves no tokens,
+    // so it needs no allowance.
+    query: {
+      enabled:
+        Boolean(to) && (amountWei === BigInt(0) || sufficientTransferAllowance),
+    },
     address: bondingManagerAddress,
     abi: bondingManager,
     functionName: "bondWithHint",
     args: [
-      BigInt(bondWithHintArgs.amount?.toString()),
+      bondWithHintArgs.amount,
       to,
       oldDelegateNewPosPrev,
       oldDelegateNewPosNext,
@@ -167,22 +193,6 @@ const Delegate = ({
   const [approvalSubmitted, setApprovalSubmitted] = useState<boolean>(false);
 
   const amountIsNonEmpty = useMemo(() => amount, [amount]);
-  // `tokenBalance` and `transferAllowance` are wei, so compare in wei.
-  const amountWei = useMemo(() => {
-    try {
-      return amount ? parseEther(amount) : BigInt(0);
-    } catch {
-      return BigInt(0);
-    }
-  }, [amount]);
-  const sufficientBalance = useMemo(
-    () => amountWei > BigInt(0) && BigInt(tokenBalance ?? 0) >= amountWei,
-    [amountWei, tokenBalance]
-  );
-  const sufficientTransferAllowance = useMemo(
-    () => amountWei > BigInt(0) && BigInt(transferAllowance ?? 0) >= amountWei,
-    [amountWei, transferAllowance]
-  );
 
   // show approve flow when: no error on inputs, not approved or pending, or approved in current session
   const showApproveFlow = useMemo(

From f46987eb59652a832b6d335d1cb1fb3fab41d8cb Mon Sep 17 00:00:00 2001
From: Rick Staa <rick.staa@outlook.com>
Date: Tue, 21 Jul 2026 12:28:26 +0200
Subject: [PATCH 3/8] fix: stop an invalid amount from crashing the delegating
 widget

parseEther throws on values the amount input accepts but cannot represent as a
decimal (e.g. `1e3`). Footer called it unguarded when computing the active set
order, so typing one crashed the render.

Parse through a shared parseAmountToWei helper that returns null instead of
throwing, and treat null as "no amount entered" so the button falls back to its
existing disabled state.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 components/DelegatingWidget/Delegate.tsx | 30 +++++++++--------------
 components/DelegatingWidget/Footer.tsx   | 31 +++++++++---------------
 utils/web3.ts                            | 21 ++++++++++++++++
 3 files changed, 45 insertions(+), 37 deletions(-)

diff --git a/components/DelegatingWidget/Delegate.tsx b/components/DelegatingWidget/Delegate.tsx
index ea108ba8..24c54aca 100644
--- a/components/DelegatingWidget/Delegate.tsx
+++ b/components/DelegatingWidget/Delegate.tsx
@@ -8,6 +8,7 @@ import {
   InfoCircledIcon,
 } from "@radix-ui/react-icons";
 import { formatPercent } from "@utils/numberFormatters";
+import { parseAmountToWei } from "@utils/web3";
 import {
   useBondingManagerAddress,
   useLivepeerTokenAddress,
@@ -15,7 +16,6 @@ import {
 import { useHandleTransaction } from "hooks/useHandleTransaction";
 import { useOrchestratorRewardCutSpike } from "hooks/useOrchestratorRewardCutSpike";
 import { useMemo, useState } from "react";
-import { parseEther } from "viem";
 import { useSimulateContract, useWriteContract } from "wagmi";
 
 import ProgressSteps from "../ProgressSteps";
@@ -124,27 +124,21 @@ const Delegate = ({
     }
   );
 
-  // `type="number"` accepts values `parseEther` rejects (e.g. `1e3`), so parse
-  // once, defensively, and reuse it everywhere.
-  const amountWei = useMemo(() => {
-    try {
-      return amount ? parseEther(amount) : BigInt(0);
-    } catch {
-      return BigInt(0);
-    }
-  }, [amount]);
+  // null when the amount is absent or not yet a valid number.
+  const amountWei = useMemo(() => parseAmountToWei(amount), [amount]);
+  const bondAmountWei = amountWei ?? 0n;
   // `tokenBalance` and `transferAllowance` are wei, so compare in wei.
   const sufficientBalance = useMemo(
-    () => amountWei > BigInt(0) && BigInt(tokenBalance ?? 0) >= amountWei,
-    [amountWei, tokenBalance]
+    () => bondAmountWei > 0n && BigInt(tokenBalance ?? 0) >= bondAmountWei,
+    [bondAmountWei, tokenBalance]
   );
   const sufficientTransferAllowance = useMemo(
-    () => amountWei > BigInt(0) && BigInt(transferAllowance ?? 0) >= amountWei,
-    [amountWei, transferAllowance]
+    () => bondAmountWei > 0n && BigInt(transferAllowance ?? 0) >= bondAmountWei,
+    [bondAmountWei, transferAllowance]
   );
 
   const bondWithHintArgs = {
-    amount: amountWei,
+    amount: bondAmountWei,
     to,
     oldDelegateNewPosPrev,
     oldDelegateNewPosNext,
@@ -159,7 +153,7 @@ const Delegate = ({
     // so it needs no allowance.
     query: {
       enabled:
-        Boolean(to) && (amountWei === BigInt(0) || sufficientTransferAllowance),
+        Boolean(to) && (bondAmountWei === 0n || sufficientTransferAllowance),
     },
     address: bondingManagerAddress,
     abi: bondingManager,
@@ -229,7 +223,7 @@ const Delegate = ({
     reset();
   };
 
-  if (!amountIsNonEmpty && !isTransferStake) {
+  if (amountWei === null && !isTransferStake) {
     return (
       <Button size="4" disabled variant="neutral" css={{ width: "100%" }}>
         Enter an Amount
@@ -237,7 +231,7 @@ const Delegate = ({
     );
   }
 
-  if (amountIsNonEmpty && +amount >= 0 && !sufficientBalance) {
+  if (amountWei !== null && !sufficientBalance) {
     return (
       <Button size="4" disabled variant="neutral" css={{ width: "100%" }}>
         Insufficient Balance
diff --git a/components/DelegatingWidget/Footer.tsx b/components/DelegatingWidget/Footer.tsx
index 5de1ed0e..b51da7f4 100644
--- a/components/DelegatingWidget/Footer.tsx
+++ b/components/DelegatingWidget/Footer.tsx
@@ -6,6 +6,7 @@ import {
   simulateNewActiveSetOrder,
 } from "@lib/utils";
 import { Box, Button } from "@livepeer/design-system";
+import { parseAmountToWei } from "@utils/web3";
 import { AccountQueryResult, OrchestratorsSortedQueryResult } from "apollo";
 import {
   StakingAction,
@@ -16,7 +17,6 @@ import {
 } from "hooks";
 import { CHAIN_INFO } from "lib/chains";
 import { useMemo } from "react";
-import { parseEther } from "viem";
 
 import Delegate from "./Delegate";
 import Footnote from "./Footnote";
@@ -91,15 +91,12 @@ const Footer = ({
         : null,
     [delegatorPendingStakeAndFees]
   );
+  // null when the amount is absent or not yet a valid number.
+  const amountWei = useMemo(() => parseAmountToWei(amount), [amount]);
   const sufficientStake = useMemo(() => {
-    if (!delegator || !amount || stakeWei === null) return false;
-    try {
-      const amountWei = parseEther(amount);
-      return amountWei <= stakeWei;
-    } catch {
-      return false;
-    }
-  }, [delegator, amount, stakeWei]);
+    if (!delegator || amountWei === null || stakeWei === null) return false;
+    return amountWei <= stakeWei;
+  }, [delegator, amountWei, stakeWei]);
   const canUndelegate = useMemo(
     () => isMyTranscoder && isDelegated && parseFloat(amount) > 0,
     [isMyTranscoder, isDelegated, amount]
@@ -109,11 +106,11 @@ const Footer = ({
       simulateNewActiveSetOrder({
         action,
         transcoders: JSON.parse(JSON.stringify(transcoders)),
-        amount: parseEther(amount ? amount.toString() : "0"),
+        amount: amountWei ?? 0n,
         newDelegate: transcoder?.id ?? "",
         oldDelegate: delegator?.delegate?.id,
       }),
-    [action, transcoders, amount, transcoder, delegator]
+    [action, transcoders, amountWei, transcoder, delegator]
   );
   const { newPosPrev, newPosNext } = useMemo(
     () => getHint(delegator?.delegate?.id, newActiveSetOrder),
@@ -135,15 +132,11 @@ const Footer = ({
   );
   const willDeactivate = useMemo(() => {
     // Wait for stake data to load before determining deactivation
-    if (!isOwnOrchestrator || stakeWei === null || !amount) return false;
-    try {
-      const amountWei = parseEther(amount);
-      // Deactivates if unbonding all stake (amount >= current stake)
-      return amountWei > 0n && amountWei >= stakeWei;
-    } catch {
+    if (!isOwnOrchestrator || stakeWei === null || amountWei === null)
       return false;
-    }
-  }, [isOwnOrchestrator, stakeWei, amount]);
+    // Deactivates if unbonding all stake (amount >= current stake)
+    return amountWei > 0n && amountWei >= stakeWei;
+  }, [isOwnOrchestrator, stakeWei, amountWei]);
 
   if (isWrongRouteChain) {
     return (
diff --git a/utils/web3.ts b/utils/web3.ts
index dd113ac9..cd4047a2 100644
--- a/utils/web3.ts
+++ b/utils/web3.ts
@@ -64,6 +64,27 @@ export const fromWei = (wei: bigint | string | null | undefined) => {
  */
 export const toWei = (ether: number) => parseEther(ether.toString());
 
+/**
+ * Parse a user-entered amount into Wei.
+ *
+ * `parseEther` throws on values `<input type="number">` accepts but cannot
+ * represent as a decimal (e.g. `1e3`), which would crash the render.
+ *
+ * @param amount - The user-entered amount in Ether
+ * @returns BigInt representation in Wei, or null when the amount is absent or
+ *   not a valid decimal number
+ */
+export const parseAmountToWei = (amount: string | null | undefined) => {
+  if (!amount) {
+    return null;
+  }
+  try {
+    return parseEther(amount);
+  } catch {
+    return null;
+  }
+};
+
 /**
  * Shorten an Ethereum address for display.
  * @deprecated Use formatAddress instead

From e70946432a464cb0d8d955c72d75ed8462e14fff Mon Sep 17 00:00:00 2001
From: Rick Staa <rick.staa@outlook.com>
Date: Tue, 21 Jul 2026 12:30:11 +0200
Subject: [PATCH 4/8] fix: accept exponent notation in the delegate amount

The amount input accepts `1e-2`, but parseEther rejects it, so valid amounts
were treated as no input at all. Normalise exponent notation to a decimal
before parsing; plain decimals skip Number to avoid float precision loss.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 utils/web3.ts | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/utils/web3.ts b/utils/web3.ts
index cd4047a2..58c43bd1 100644
--- a/utils/web3.ts
+++ b/utils/web3.ts
@@ -67,8 +67,9 @@ export const toWei = (ether: number) => parseEther(ether.toString());
 /**
  * Parse a user-entered amount into Wei.
  *
- * `parseEther` throws on values `<input type="number">` accepts but cannot
- * represent as a decimal (e.g. `1e3`), which would crash the render.
+ * `parseEther` throws on the exponent notation `<input type="number">` accepts
+ * (e.g. `1e3`), so those are normalised to a decimal first. Plain decimals skip
+ * `Number` to avoid float precision loss.
  *
  * @param amount - The user-entered amount in Ether
  * @returns BigInt representation in Wei, or null when the amount is absent or
@@ -79,7 +80,7 @@ export const parseAmountToWei = (amount: string | null | undefined) => {
     return null;
   }
   try {
-    return parseEther(amount);
+    return parseEther(/[eE]/.test(amount) ? Number(amount).toString() : amount);
   } catch {
     return null;
   }

From 4f4d92435fb6a6906a66e015a62bb2b6f16e82a3 Mon Sep 17 00:00:00 2001
From: Rick Staa <rick.staa@outlook.com>
Date: Tue, 21 Jul 2026 12:57:10 +0200
Subject: [PATCH 5/8] test: cover amount parsing

parseAmountToWei had no tests. Pin the decimal, exponent, and null cases, and
the precision behaviour that requires exponents alone to route through Number.
The boundary test records that exponents outside the range Number writes as a
decimal are rejected, while the same value in decimal notation is not.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 utils/web3.test.ts | 43 ++++++++++++++++++++++++++++++++++++++++++-
 utils/web3.ts      | 15 ++++++---------
 2 files changed, 48 insertions(+), 10 deletions(-)

diff --git a/utils/web3.test.ts b/utils/web3.test.ts
index b2a9402b..b556b913 100644
--- a/utils/web3.test.ts
+++ b/utils/web3.test.ts
@@ -1,4 +1,10 @@
-import { checkAddressEquality, formatAddress, fromWei, toWei } from "./web3";
+import {
+  checkAddressEquality,
+  formatAddress,
+  fromWei,
+  parseAmountToWei,
+  toWei,
+} from "./web3";
 
 describe("checkAddressEquality", () => {
   it("returns false for invalid addresses", () => {
@@ -43,6 +49,41 @@ describe("toWei", () => {
   });
 });
 
+describe("parseAmountToWei", () => {
+  it("converts decimal amounts to wei", () => {
+    expect(parseAmountToWei("0.1")).toBe(100000000000000000n);
+    expect(parseAmountToWei("2.5")).toBe(2500000000000000000n);
+    expect(parseAmountToWei("100000")).toBe(100000000000000000000000n);
+  });
+
+  it("keeps decimals that exceed float precision", () => {
+    expect(parseAmountToWei("1.000000000000000001")).toBe(1000000000000000001n);
+  });
+
+  it("accepts exponent notation", () => {
+    expect(parseAmountToWei("1e3")).toBe(1000000000000000000000n);
+    expect(parseAmountToWei("1E3")).toBe(1000000000000000000000n);
+    expect(parseAmountToWei("1e-2")).toBe(10000000000000000n);
+  });
+
+  it("returns null for an absent or unparseable amount", () => {
+    expect(parseAmountToWei("")).toBeNull();
+    expect(parseAmountToWei(null)).toBeNull();
+    expect(parseAmountToWei(undefined)).toBeNull();
+    expect(parseAmountToWei("abc")).toBeNull();
+    expect(parseAmountToWei("1e")).toBeNull();
+  });
+
+  // Exponents are normalised through `Number`, which only writes decimals
+  // between 1e-6 and 1e21. Decimal notation has no such limit.
+  it("rejects exponents outside the range Number writes as a decimal", () => {
+    expect(parseAmountToWei("1e-6")).toBe(1000000000000n);
+    expect(parseAmountToWei("1e-7")).toBeNull();
+    expect(parseAmountToWei("0.0000001")).toBe(100000000000n);
+    expect(parseAmountToWei("1e21")).toBeNull();
+  });
+});
+
 describe("formatAddress", () => {
   it("shortens a normal ethereum address", () => {
     const addr = "0x1234567890abcdef1234567890abcdef12345678";
diff --git a/utils/web3.ts b/utils/web3.ts
index 58c43bd1..e44ab855 100644
--- a/utils/web3.ts
+++ b/utils/web3.ts
@@ -58,7 +58,8 @@ export const fromWei = (wei: bigint | string | null | undefined) => {
 };
 
 /**
- * Convert Ether amount (number) to Wei (bigint)
+ * Convert Ether amount (number) to Wei (bigint).
+ * @deprecated Use parseAmountToWei instead.
  * @param ether - The value in Ether
  * @returns BigInt representation in Wei
  */
@@ -67,18 +68,14 @@ export const toWei = (ether: number) => parseEther(ether.toString());
 /**
  * Parse a user-entered amount into Wei.
  *
- * `parseEther` throws on the exponent notation `<input type="number">` accepts
- * (e.g. `1e3`), so those are normalised to a decimal first. Plain decimals skip
- * `Number` to avoid float precision loss.
+ * `parseEther` only accepts decimals, so exponent notation (e.g. `1e3`) is
+ * normalised first.
  *
  * @param amount - The user-entered amount in Ether
- * @returns BigInt representation in Wei, or null when the amount is absent or
- *   not a valid decimal number
+ * @returns BigInt representation in Wei, or null when it cannot be parsed
  */
 export const parseAmountToWei = (amount: string | null | undefined) => {
-  if (!amount) {
-    return null;
-  }
+  if (!amount) return null;
   try {
     return parseEther(/[eE]/.test(amount) ? Number(amount).toString() : amount);
   } catch {

From 2116341548f0ff86ee0f5581db028f8fdc78a197 Mon Sep 17 00:00:00 2001
From: Rick Staa <rick.staa@outlook.com>
Date: Tue, 21 Jul 2026 13:06:14 +0200
Subject: [PATCH 6/8] refactor: drop the amountIsNonEmpty indirection

amountIsNonEmpty returned the amount string rather than a boolean, and only
worked because every use site read it for truthiness. Its last use asks whether
there is an amount worth approving for, which amountWei answers directly.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 components/DelegatingWidget/Delegate.tsx | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/components/DelegatingWidget/Delegate.tsx b/components/DelegatingWidget/Delegate.tsx
index 24c54aca..28f7d6e6 100644
--- a/components/DelegatingWidget/Delegate.tsx
+++ b/components/DelegatingWidget/Delegate.tsx
@@ -186,14 +186,12 @@ const Delegate = ({
 
   const [approvalSubmitted, setApprovalSubmitted] = useState<boolean>(false);
 
-  const amountIsNonEmpty = useMemo(() => amount, [amount]);
-
   // show approve flow when: no error on inputs, not approved or pending, or approved in current session
   const showApproveFlow = useMemo(
     () =>
-      (amountIsNonEmpty && +amount >= 0 && !sufficientTransferAllowance) ||
+      (amountWei !== null && !sufficientTransferAllowance) ||
       (approvalSubmitted && sufficientTransferAllowance),
-    [amount, amountIsNonEmpty, sufficientTransferAllowance, approvalSubmitted]
+    [amountWei, sufficientTransferAllowance, approvalSubmitted]
   );
 
   const onApprove = async () => {

From 71f191016f8f413043c4b6a5fd8970be31b6ce2d Mon Sep 17 00:00:00 2001
From: Rick Staa <rick.staa@outlook.com>
Date: Tue, 21 Jul 2026 14:12:20 +0200
Subject: [PATCH 7/8] fix: stop an invalid amount from bonding nothing

A stake transfer bonds zero to switch delegate, so the empty-amount branch let
any unparseable amount through as well. Entering one would move the delegation
without adding the stake that was typed.

Allow the fall-through only when the field is genuinely empty.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-Authored-By: CodeRabbit <coderabbitai[bot]@users.noreply.github.com>
---
 components/DelegatingWidget/Delegate.tsx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/components/DelegatingWidget/Delegate.tsx b/components/DelegatingWidget/Delegate.tsx
index 28f7d6e6..9168c4b7 100644
--- a/components/DelegatingWidget/Delegate.tsx
+++ b/components/DelegatingWidget/Delegate.tsx
@@ -221,7 +221,8 @@ const Delegate = ({
     reset();
   };
 
-  if (amountWei === null && !isTransferStake) {
+  // A stake transfer may bond nothing, but only from an empty field.
+  if (amountWei === null && (amount || !isTransferStake)) {
     return (
       <Button size="4" disabled variant="neutral" css={{ width: "100%" }}>
         Enter an Amount

From 11c81fdc1649265e6be7753e0000625ebf24da8e Mon Sep 17 00:00:00 2001
From: Rick Staa <rick.staa@outlook.com>
Date: Tue, 21 Jul 2026 15:15:19 +0200
Subject: [PATCH 8/8] docs: trim the simulation gate comment

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 components/DelegatingWidget/Delegate.tsx | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/components/DelegatingWidget/Delegate.tsx b/components/DelegatingWidget/Delegate.tsx
index 9168c4b7..c489a916 100644
--- a/components/DelegatingWidget/Delegate.tsx
+++ b/components/DelegatingWidget/Delegate.tsx
@@ -147,10 +147,8 @@ const Delegate = ({
   };
 
   const { data: bondWithHintConfig } = useSimulateContract({
-    // Simulating without the allowance in place reverts, and nothing re-runs a
-    // cached failure once the approval lands. Gating on the allowance means the
-    // simulation first runs when it can succeed. A zero amount moves no tokens,
-    // so it needs no allowance.
+    // A reverted simulation is cached and never re-run, so only simulate once
+    // it can succeed. A zero amount moves no tokens, so it needs no allowance.
     query: {
       enabled:
         Boolean(to) && (bondAmountWei === 0n || sufficientTransferAllowance),