Money is never where the trade is.

You want to put $40 on a market. You have $6 of one stablecoin on one chain, $18 of another on a second chain, and $30 sitting inside a venue you're not betting on today. A funding planner's job is to turn that into a short list of steps: read every balance you have, pick one route that covers the whole shortfall, price each leg backwards from the destination, and tell you honestly how long it will take.

A venue does not accept "money"

This is the fact everything else follows from. A venue accepts one token contract, on one chain, held by one specific address. Miss any of the three and the money is not late, it is in the wrong place entirely.

"Your USDC" is at least four different objects. On Polygon there is native USDC and there is USDC.e, the older bridged version — same price, different contracts, not interchangeable. On Arbitrum the native one is a third contract. On BNB, the stablecoins have 18 decimals rather than the six everyone assumes, which is a whole class of off-by-a-trillion bugs waiting for anyone who hard-codes it. And the address matters as much as the token: a Polymarket balance lives in a deposit wallet derived from your own address, which is not your wallet, and money on its way there passes through a bridge inbox, which is a third address again.

Chain	What venues actually take	Decimals
Polygon	native USDC, bridged USDC.e, USDT — and pUSD inside a Polymarket deposit wallet	6
Arbitrum	native USDC (not USDC.e) — the on-ramp for perps and FX hedges	6
Base	native USDC	6
BNB	USDT and USD1 — and which one is per market, not per venue	18

That last row is not a detail. On one venue, most BNB markets settle in USD1 rather than USDT — so a planner that treated "a dollar stablecoin on BNB" as one thing would run a bridge, charge you a fee, and leave you holding a token the market cannot accept. The registry has to be per token, not per chain, and a destination that isn't in it has no route at all rather than a route into a dead end.

The algorithm, in five moves

Given a destination — chain, token, amount — the planner:

1. Reads every balance. Ten of them: three stablecoins on Polygon, native USDC on Arbitrum, two on BNB, the Polymarket balance in both the deposit wallet and your own wallet, your perps account, and whatever is already sitting at the destination.
2. Works out the shortfall. What you already hold at the destination counts, so the plan is for the gap, not the whole amount.
3. Builds a ranked list of candidate sources. Each candidate knows two things: what it would cost at the source to land any amount at the destination, and which legs that would take.
4. Takes the first candidate that covers the whole shortfall. One source, whole amount.
5. If none does, it combines, biggest first, fewest legs. If even everything together falls short, it says by how much rather than planning something that dies halfway.

Two things about that are worth saying plainly. First, the preference for a single source is deliberate: stitching partial amounts across differently priced routes is fragile, and "add $4 more" is a better answer than a plan with three bridges in it. Second — and this is the honest caveat — the ranking is hand-written, not solved. It encodes knowledge (already at the destination beats a same-chain swap, which beats a cross-chain hop, which beats a venue's own bridge) rather than comparing live quotes from every rail for every candidate. A true optimiser would need a quote from each before it could show you anything, and a bet slip that takes eight seconds to appear is a worse product than one that is occasionally a few cents off the theoretical best.

One small rule in the balance read does more work than it looks like: the perps account is read for what is withdrawable, never its total value. Money backing an open position cannot leave, so counting it would plan a route that fails at its first leg — the most annoying possible failure, because it fails after you have already signed something.

A route, with its legs and its clock

Every leg is priced backwards from the destination: the last leg needs to deliver the amount, the one before it has to deliver that plus its own cost, and so on up to the source. So the number that leaves your balance is always larger than the number that arrives, and the difference is legible rather than a mystery fee.

Why the estimate is a range

A single number can't say "eight seconds or seventy". An intent-based bridge often fills in one block and occasionally waits for a relayer; a batch-auction swap settles whenever the next auction runs; a venue's own deposit relayer takes minutes on a good day. Averaging those produces a figure that is wrong in both directions at once.

So the honest version is a window with four states — on its way, due any moment, taking longer than usual, still on its way, and arrived — where the third one is a real state rather than a failure. And crucially, the wait ends when the money lands, not when the clock does: each leg polls the destination balance until it actually moves, so the timer is a courtesy and the balance is the truth.

Minimums are where money actually dies

Every rail has a floor, and the floors behave very differently below the line.

• A perps bridge may simply keep a deposit under its minimum — five dollars, in the case relevant here, and under it the money is gone, not bounced. So the planner does something that looks wrong and isn't: asked to move $2 there, it moves $5. A $2 route into that venue is not a small route, it is a route that does not exist, and the surplus lands in your own account where you can withdraw it. For the same reason a route into it is never split across two sources — two part-deposits could each land under the floor.
• A withdrawal can have its own floor and its own flat fee, which changes the arithmetic of small amounts entirely: a two-dollar minimum with a one-dollar fee means half of the smallest legal withdrawal is the fee.
• A deposit bridge may hold the money instead. This is the kindest failure and the most confusing one, because the balance shows zero everywhere while the money sits perfectly safe at an address you didn't know existed.

That last one is worth telling properly, because it is what building on undocumented infrastructure actually looks like. The floor was not published anywhere, so it had to be established by watching. Two sub-dollar top-ups stranded, which suggested a dollar. Then a $1.65 deposit stranded too — while sweeps of $3.38 and $5.07 on the same address both cleared in about forty seconds. So the true floor is somewhere in the interval (1.65, 3.38], and the number the software enforces is $2.00: the first round figure above everything ever seen to fail, to be raised again if anything above it ever strands.

Gas: the chicken-and-egg leg

You cannot send a transaction on a chain where you hold none of its native token. You also cannot buy that native token without sending a transaction. Every cross-chain design has to break this loop somewhere, and there are only two honest ways:

• A signature-settled swap. Order types like CoW Protocol's are executed by a solver who pays the gas, so a wallet with exactly zero native token can still trade its way into some.
• A bridge that drops native gas at the destination in the same operation, paid for out of the amount leaving the source.

How much gas is its own small problem. A flat dollar is either wasteful or useless depending on the chain and the hour, so the amount is computed: the chain's current gas price, times a realistic worst-case action, times enough actions to be worth the trip — floored so a price spike can't strand you and capped so it can't get silly. The measurable difference: on one route, $10 of stablecoin arriving at the destination landed as 8.91 with a flat drop and 9.68 with a sized one.

What goes wrong

The most common failure isn't technical, it's a person changing their mind. If you decline a signature partway through, nothing after it is signed — but your money is now somewhere in the middle of the route. That's a legitimate state, and the only decent response is to say where it is now and restart from there rather than from the beginning, because the shortest way out of the middle of a route is rarely back the way you came.

The other honest limits are boundaries rather than bugs. Ethereum mainnet isn't a funding source or destination here, and neither is Solana. Fixed-yield positions aren't self-funding: they spend what is already on their chain, so the money has to be moved there first. And a plan is a plan — a rail can be slower than its window, a swap can settle at a worse price than quoted, and a bridge can have a bad day. The design does not pretend otherwise; it just makes sure that when it happens you can see where your money is.