The Number Is Wrong By The Time Everyone Has Signed.

Say your company holds its money onchain. There is a good chance it sits in a Safe, which is a shared account where nothing moves unless several named people approve it. That is the correct way to hold money that is not yours alone.

Now you want to unstake the treasury's ETH.

You open the transaction builder, you type the amount, and you send it around for approvals. Four people have to say yes. The first signs in a minute. The last one is asleep in another timezone and gets to it tomorrow.

By the time they do, the amount you typed is wrong.

It is not wrong by much. Staked ETH grows a little every day, so a balance measured on Tuesday is bigger on Wednesday, and the Safe does not care by how much. The people who approved put their names to an exact instruction containing an exact figure, and an instruction containing a different figure is a different instruction that nobody has approved. Correct the amount and every signature you collected is worth nothing. You start the round again from the first person.

Both references above are real. We built the same withdrawal twice, moved nothing but the amount, and asked a live Safe what its owners would be shown. It runs against a stand-in account, so it names nobody's wallet and anybody can do it again.

Grant Safe this outright, because it is the entire reason to use one.

An owner approving something in a Safe is not approving a plan or an intention. They are approving one exact list of steps, down to the last digit, and the account will refuse to execute anything else under their name for as long as it exists. That is the guarantee people are paying for. It is why you can send five colleagues a link and be certain the thing they read is the only thing that can happen.

The cost of that guarantee is that the instruction has to be finished before anybody looks at it. There is no way to write down all of it, or whatever is in the account when this runs. There is only a figure, typed by a person, hours before the money actually moves.

Staked ETH is not a balance that sits still. Lido pays its stakers by growing everyone's holdings a little each day, so the position is a moving quantity by design.

We read every one of those payouts over the last three months straight off the chain, ninety-three of them. The position grew 0.5820% across ninety-two days, which is 0.006307% a day, or 2.302% a year.

On a thousand staked ETH that is 0.063 ETH a day. Roughly two hundred dollars, arriving in the account after you typed the number and before the last person signed.

Two hundred dollars is not the injury. The injury is that the instruction now unstakes less than the position holds, so a remainder is stranded, and collecting it means building the whole thing a second time and walking it back around every owner for approvals they already gave once.

Round up instead and it is worse. The instruction asks for more than the account holds, the chain throws the whole thing out, and whoever submitted it paid for the failure. The position has not moved an inch and you are still building a second batch.

Lido's withdrawal queue will not take more than 1,000 stETH in one request. The contract at 0x889edC2eDab5f40e902b864aD4d7AdE8E412F9B1 enforces that on every request it receives, so a large position has to be broken into several, and how many of them there are depends on a balance that nobody can pin down until the moment the transaction actually runs.

Three thousand stETH is three requests. Tomorrow the same position is 3,000.19 stETH and it is four requests, the fourth one existing entirely to collect nineteen hundredths of a token.

So the batch is not just carrying a stale figure. It is carrying the wrong number of steps, and whoever built it had to predict that too.

All of this depends on how long the gap is between typing the number and spending it, so we went and measured the gap instead of guessing at it.

Every time an owner approves a Safe transaction onchain, the account announces it publicly, and it announces again when that transaction finally executes, so lining the two up gives you the wait exactly, for anybody who cares to go and check it themselves. Nothing about that is private. Across four months of Ethereum history that comes to 17,628 matched pairs on 255 different Safes.

One owner is twelve seconds. Same person, same sitting, nobody to wait for. Two or three owners and the middle of the pack is ten minutes. Four or more and it is nineteen hours, with ninety-three percent of them sitting longer than an hour before the figure they carry is finally spent.

That top group is seven Safes, so hold the exact hours loosely and the shape firmly. The shape is what matters. The more people a company requires before money moves, the longer its numbers sit before they are used, and a company that requires four approvals is not somebody's personal wallet. It is the one holding other people's money.

The treasuries carrying the most are the ones whose figures rot the longest.

There is a fix inside Safe, and treasuries know about it. You write a small piece of custom code that reads the balance and does the arithmetic itself, and you have the Safe run that instead of a fixed list of steps. The amount comes out right. It was worked out on the spot.

Look at what the owners approve when they do that. It is permission to run somebody's code inside the account, with the account's full authority, and that code can do anything the account can do, up to and including quietly replacing the owners with a different set of people. Every piece of security guidance a multisig operator has ever been handed says do not approve that without reading the code first, which in practice means paying for an audit before you have paid for gas.

Most desks price that once and go back to typing numbers.

The instinct underneath it is correct, though. If the quantity cannot be known in advance, the thing being signed should not contain a quantity. It should contain the question, and the answer should be worked out at the moment it runs.

Plug's unstaking plug leaves the amount blank on purpose.

What gets approved is the instruction. Unstake from Lido, wait for the queue to clear it, restake the proceeds. The amount is a hole in the middle of it, and the hole is filled at the moment of execution by reading the balance that is actually there. The number of requests is worked out then too, against the same limit that would have broken the batch.

Nothing needs re-approving, because the instruction never changed. It never contained the figure in the first place. Money can arrive in the position between the first approval and the execution, and the program takes it along.

That is the whole difference. A batch is a photograph of a decision somebody made yesterday. A plug is the decision itself, still able to look at the account when it fires.

Custody, which is what it is for and what it is good at. Owners, a threshold, a recovery path, and a flat refusal to do anything nobody approved. None of that is in question here and none of it is replaced by any of this.

The transaction builder is the part that cannot follow, and specifically for anything whose size is decided by the chain rather than by a person. Unstaking. Unwinding a leveraged position. Sweeping an account to empty. Rebalancing to a target weight. Repaying a loan whose interest ticks up while the approvals come in. Each one has a correct amount that only exists at the moment it runs, and a batch has to guess it hours early and then be right.

Sign the instruction. The figure will be there when it matters.