Issue with Resize / Top-Up Flow – “Insufficient Unified Balance”

[rahimunlu]

Hi team,

I’m experiencing an issue when trying to perform a resize operation — I keep getting the error:

insufficient unified balance for channel ... required 100000, available 82000

In this case, I’m trying to transfer 0.1 usdc from my wallet to the Unified Balance. The Unified Balance currently holds 0.08 USDC, but even after approval, the resize call fails with the same error.

Here’s the context:
I already have a main setup where funds are deposited and transferred between channels using Virtual Sessions from the Unified Balance and it works great. So now, Instead of creating a new channel, I’m trying to increase the existing Unified Balance via the resize function — essentially, to implement a top-up mechanism.

Below is the function I’m currently using. I’ve tried multiple approaches, but none have worked so far. I’d really appreciate your help understanding what might be causing this issue.

---

Function

const topUpUnifiedBalance = useCallback(
  async (amountDecimal: string): Promise<boolean> => {
    if (!walletAddress || !walletClient) {
      setError("Wallet not connected");
      return false;
    }

    setIsLoading(true);
    setError(null);

    try {
      const { createPublicClient, http } = await import("viem");
      const { polygon } = await import("viem/chains");
      const { NitroliteClient } = await import("@erc7824/nitrolite");

      const tokenAddress = process.env.NEXT_PUBLIC_USDC_TOKEN_ADDRESS as `0x${string}`;
      if (!tokenAddress) throw new Error("USDC token address not configured");

      const raw = toRawUsdc(amountDecimal);
      if (raw <= 0n) throw new Error("Amount must be greater than 0");

      // Channel ID
      let channelId = paymentChannel?.channelId;
      if (!channelId || channelId.startsWith("clearnode_")) {
        channelId = await ensureOpenChannelId();
      }

      if (!channelId) return await depositToUnifiedBalance(amountDecimal);

      // RPC Signer
      const { rpcSigner, stateWallet } = await getRpcSigner();

      // Broker Config
      const { createGetConfigMessage } = await import("@erc7824/nitrolite");
      const getConfigMsg = await createGetConfigMessage(rpcSigner);
      const brokerConfig = await clearNodeClient.sendRequest(getConfigMsg);

      const polygonNetwork = (brokerConfig as any).networks?.find(
        (n: { chain_id: number }) => n.chain_id === 137
      );
      if (!polygonNetwork?.custody_address)
        throw new Error("Polygon network not configured");

      // Public Client
      const publicClient = createPublicClient({
        chain: polygon,
        transport: http(),
      });

      // 📝 Step 1/3: Approve USDC for deposit
      const erc20Abi = [
        {
          name: "approve",
          type: "function",
          stateMutability: "nonpayable",
          inputs: [
            { name: "spender", type: "address" },
            { name: "amount", type: "uint256" },
          ],
          outputs: [{ type: "bool" }],
        },
      ] as const;

      console.log("📝 Step 1/3: Approving USDC for deposit...");
      const approvalHash = await walletClient.writeContract({
        address: tokenAddress,
        abi: erc20Abi,
        functionName: "approve",
        args: [polygonNetwork.custody_address as `0x${string}`, raw],
        account: walletAddress,
        chain: polygon,
      });

      console.log("⏳ Waiting for approval confirmation...");
      await publicClient.waitForTransactionReceipt({ hash: approvalHash });
      console.log("✅ USDC approved:", approvalHash);

      // 📤 Step 2/3: Send resize_channel RPC
      const reqId = Date.now();
      const payload: [number, string, any, number] = [
        reqId,
        "resize_channel",
        {
          channel_id: channelId,
          resize_amount: raw.toString(),    // ✅ Deposit amount
          allocate_amount: "0",             // ✅ Don’t touch unified allocation
          funds_destination: walletAddress,
        },
        Date.now(),
      ];

      console.log("📤 Step 2/3: Sending resize_channel RPC...");
      console.log(`  resize_amount: +${raw} (deposit)`);
      console.log(`  allocate_amount: 0 (no allocation from unified)`);

      const sig = await rpcSigner(payload);
      const envelope = { req: payload, sig: [sig] };
      const resp = await clearNodeClient.sendRequest(JSON.stringify(envelope));

      // Response validation
      const respData = resp as any;
      if (!respData || !respData.res) throw new Error("Invalid broker response");

      const [, method, params] = respData.res;
      if (method === "error") {
        throw new Error(`Broker error: ${params?.error || "Unknown"}`);
      }
      if (method !== "resize_channel") {
        throw new Error(`Unexpected method: ${method}`);
      }

      if (!params.channel_id || !params.state || !params.server_signature) {
        throw new Error("Invalid resize response");
      }

      // ⛓️ Step 3/3: Execute on-chain resize
      console.log("⛓️  Step 3/3: Executing on-chain resize...");

      const nitroliteClient = new NitroliteClient({
        publicClient,
        walletClient: walletClient as any,
        stateSigner: stateWallet as any,
        addresses: {
          custody: polygonNetwork.custody_address as `0x${string}`,
          adjudicator: polygonNetwork.adjudicator_address as `0x${string}`,
          guestAddress: (brokerConfig as { broker_address: string }).broker_address as `0x${string}`,
        },
        chainId: 137,
        challengeDuration: 3600n,
      });

      const resizeTxHash = await nitroliteClient.resize(
        params.channel_id as `0x${string}`,
        {
          intent: params.state.intent,
          version: BigInt(params.state.version),
          data: params.state.state_data as `0x${string}`,
          allocations: params.state.allocations.map((a: any) => ({
            destination: a.destination as `0x${string}`,
            token: a.token as `0x${string}`,
            amount: BigInt(a.amount),
          })),
        },
        params.server_signature as `0x${string}`,
      );

      console.log("⏳ Waiting for resize transaction...");
      await publicClient.waitForTransactionReceipt({ hash: resizeTxHash });
      console.log("✅ Top-Up successful! TX:", resizeTxHash);

      await refreshUnifiedBalance();
      return true;
    } catch (err) {
      const msg = err instanceof Error ? err.message : "Top-Up failed";
      console.error("❌ Top-Up failed:", err);
      setError(msg);
      return false;
    } finally {
      setIsLoading(false);
    }
  },
  [
    walletAddress,
    walletClient,
    paymentChannel,
    ensureOpenChannelId,
    depositToUnifiedBalance,
    getRpcSigner,
    clearNodeClient,
    refreshUnifiedBalance,
  ],
);

---

Console Output

🚀 Connect called with authParams:
  walletAddress: 0x9F0dfC9b803EF2Ad1885f5C0C2d0c552B2616c34
  signerAddress: 0x9F0dfC9b803EF2Ad1885f5C0C2d0c552B2616c34
  walletClient.account: 0x9F0dfC9b803EF2Ad1885f5C0C2d0c552B2616c34
  stateWallet after init: 0xC51604Bd6C4Dc65d465d08EF569048A53948F5Dd
📝 Step 1/3: Approving USDC for deposit...
⏳ Waiting for approval confirmation...
✅ USDC approved: 0x737b93093e35721574242b730337429f1db7ae008aaf87c7d7ed0acefd66bdc1
📤 Step 2/3: Sending resize_channel RPC...
  resize_amount: +100000 (deposit)
  allocate_amount: 0 (no allocation from unified)
⚠️ Broker response:
  error: "insufficient unified balance for channel 0x48a3f4...: required 100000, available 82000"
❌ Top-Up failed: Error: Invalid broker response

[nksazonov]

Hey @rahimunlu ! Thank you for building on Yellow Network!
Do I understand correctly that you already have some funds deposited to the Custody Smart Contract and you want to bring them to your Unified Balance?
If so, then you should also specify allocate_amount as -resize_amount, which is -100000 in your case.
The resize_amount corresponds to how much funds you want to transfer from Custody-locked to Channel-locked balance, and in your case it is 0.1 USDC.
The allocate_amount means how much funds you want to transfer from your Unified balance to Channel-locked one, but in your case you want to do the opposite - top-up the unified balance -, thus you should specify -0.1 USDC.

[rahimunlu]

Hey, thanks for the detailed explanation!

I think there’s a misunderstanding about my use case, so here’s the clarification:

I’m not trying to move existing custodied funds into my Unified Balance.
I want to deposit new USDC from my wallet (MetaMask) to top up my Unified Balance, while reusing an existing channel (same chain_id/token) instead of creating a new one.

My current flow:

1. approve(USDC, custody_address, amount) from my wallet

2. Call resize_channel with:

   {
     "channel_id": "0x48a3f4...",
     "resize_amount": "10000",
     "funds_destination": "0x9F0dfC9b803EF2Ad1885f5C0C2d0c552B2616c34"
   }

   (allocate_amount omitted/0)

3. Use the returned state + server signature with NitroliteClient.resize(...) on-chain.

But I get this broker error:

insufficient unified balance for channel 0x48a3f4...: required 100000, available 82000

My current understanding:

• allocate_amount → moves funds between Unified Balance ↔ channel
• resize_amount → deposit/withdraw via Custody Contract

What I want:

• deposit +0.01 USDC from my wallet
• increase my Unified Balance
• reuse the existing Polygon channel

So my questions:

1. For “new wallet deposit → top up Unified on an existing channel”, what is the correct use of allocate_amount and resize_amount?

   • Should it be allocate_amount = 0 and resize_amount > 0?
   • Or is a different flow needed (e.g. create_channel, some wallet_deposit pattern, etc.)?

2. I might be wrong but my understanding was in the Go docs AllocateAmount and ResizeAmount are mutually exclusive, but you mentioned allocate_amount = -resize_amount.
   Is using both fields in one resize_channel request now recommended for “custody → unified” top-ups?

Once I understand the intended pattern for “deposit new funds from wallet and increase Unified on an existing channel”, I can update my client accordingly.

Thanks again!

[nksazonov]

1. For “new wallet deposit → top up Unified on an existing channel”, what is the correct use of allocate_amount and resize_amount?

Currently resize(...) it NOT able to perform a deposit from EOA to Custody SC, thus either Custody available balance should suffice or a separate deposit(...) transaction is required prior. Therefore the intended flow is to use NitroliteClient.deposit(tokenAddress, amount) before doing the resize.

In the next major release we indeed plan to merge this into one flow. We will notify on our developments.

---

2. I might be wrong but my understanding was in the Go docs AllocateAmount and ResizeAmount are mutually exclusive, but you mentioned allocate_amount = -resize_amount.
   Is using both fields in one resize_channel request now recommended for “custody → unified” top-ups?

In fact, they are not mutually restrictive, and yes, using both fields is not only recommended, but the only way to perform "Custody locked" -> "Unified balance" top-up (or withdrawal). It is possible to transfer any (available) amount of funds both from "Custody locked" to "Channel locked" and from "Channel locked" to "Unified balance" in the same resize(...) operation. Actually, the resize_amount = -allocate_amount is an equation that means transferring funds from "Custody locked" to "Unified balance" or vice versa. Still, we decided not to restrict the functionality here, so it is possible not to follow this equation.

However, in the (really shortly) upcoming release we are restricting operations for accounts that have "Channel balance" not equal to zero, so keep that in mind while developing your features!

[rahimunlu]

Thank you! It's much clear for me now.