Ethereum
Arbitrary call

Pennysia's $5.1K Loss and How Olympix Would Have Prevented It

Loss
Loss
Exploit date
November 12, 2026

At 13:59:11 UTC on November 12, 2026, a single Ethereum transaction pulled tokens out of four wallets. None of their owners started it. What they had in common was an old approval to Pennysia's Settlement contract, the piece of the Pennysia trading stack that users let move their tokens so a swap can go through.

The attacker walked off with 5,006.13 USDC, 0.05 wstETH and 101,000 YUNO, worth about $5.1K at the time, not counting the YUNO, which has no listed market price. The dollar figure is small, but the pattern behind it keeps costing DeFi users money, because the abused contract's real asset was the standing permission its users had given it.

What the Settlement Contract Does

Pennysia routes swaps across outside venues. Its Settlement contract, verified on Etherscan as PennysiaSettlement, takes a list of route attempts and tries them in order. A SYNC route sends the trade to an outside venue on Ethereum. A SODAX route opens a cross-chain intent through the SODAX bridge. The comments in the verified source warn that calling executeSwap directly isn't recommended and that the Pennysia web app builds the valid calldata.

To trade, a user approves the Settlement contract to spend the token they're selling. The contract pulls the tokens in, hands them to the venue, measures what comes back and pays the user. That approval model is normal for aggregators. Many wallets approve far more than one trade needs, and many never revoke, so an aggregator's settlement contract slowly collects standing permission over a lot of wallets.

A Route the Caller Writes

According to SlowMist's alert, the Settlement contract was exploited through an arbitrary external call that let the attacker spend users' leftover token approvals. SlowMist said it looked into Pennysia after users reported stolen funds.

The verified source shows how much of a route the caller controls. In the SYNC path, executeSyncAttempt reads the venue address, the call value and the calldata straight from the route the caller submitted. Its only checks on the addresses in a route are these two lines, quoted from the verified SettlementSync module:

        if (venue == address(0) || venue == address(this)) revert SelfVenueForbidden();
        if (spendAs != address(0) && allowanceTarget == address(0)) revert InvalidAddress();

A few lines later, the contract makes the call:

        uint256 spendBefore = TokenLib.balanceOfStrict(spendAs);
        (bool ok,) = venue.call{value: venueValue}(step.callData);
        if (!ok) revert SyncAttemptFailed();

Nothing in that path requires the venue to be a DEX, a router or anything on an allowlist. A token contract qualifies as a venue. Calldata that asks a token to run transferFrom against some other user's wallet qualifies as calldata. When the Settlement contract makes that call, the token sees a spender its holder approved, and it moves the funds.

After the call, the contract checks balances. It confirms that it spent some of the sell-side token and that its buy-side balance went up, then pays the increase to the caller as swap output. Tokens pulled out of a victim's wallet raise that buy-side balance exactly like a real fill would.

One Transaction, Four Wallets

The attacker's wallet deployed an attack contract at 13:55:35 UTC and called it three and a half minutes later. Every token in the exploit transaction made the same three hops: from the victim to the Settlement contract, from the Settlement contract to the attack contract, and from the attack contract to the attacker.

The largest single hit was 5,000 USDC from one wallet. A second wallet lost 6.133489 USDC, a third lost 0.05 wstETH and a fourth lost 101,000 YUNO. The first hop into the Settlement contract is the giveaway. It's the same movement a normal venue fill produces, except the tokens came out of wallets that never asked to trade.

Within a minute the attacker moved the 5,006.133489 USDC on to another address, and about a minute after that it sent the wstETH through a bridge contract. As of November 14, 2026, the 101,000 YUNO was still in the attacker's wallet.

SlowMist told anyone who had ever approved tokens to the Settlement contract to revoke those approvals. As of November 14, 2026, Pennysia hadn't posted about the incident on its X account and hadn't published a post-mortem.

Why Leftover Approvals Make This Class So Costly

An approval doesn't expire when the trade it was granted for finishes. It stays live until the owner revokes it, so the blast radius of a settlement contract bug is every wallet that still trusts it, including wallets that last traded months ago. Here the drain stopped at four wallets, and the damage stayed in the low thousands. On a busier aggregator the same lines would expose far more.

It's the same shape of bug that cost Transit Finance $1.88M in May, when a router it had deprecated years earlier still forwarded arbitrary calls to its approval contract and drained USDT from wallets that never revoked.

How Olympix Would Have Caught the Open Venue Call

Olympix reads a contract as states, transitions and entry points, and takes in context to infer the invariants the design depends on. For a settlement contract, the most valuable state is the allowance every user has granted it. The invariant follows from how the contract is meant to be used: the Settlement contract may move a user's tokens only as part of a swap that same user started.

Static analysis would have surfaced the signal in executeSyncAttempt, an external call whose target and calldata both come from the caller, reachable from the public executeSwap, in a contract that holds standing token approvals. The engine uses signals like that to narrow from every path through the contract to the feasible ones, and from there to the paths that touch the approval invariant.

BugPoCer starts from an invariant and searches outward through the system for a sequence of state changes that breaks it. Had the Pennysia team run it on the Settlement contract, it would have searched for a call by an address that isn't the token owner which ends with that owner's balance lower and the caller's balance higher. BugPoCer would have returned that sequence as a counterexample: a route whose venue is a token contract and whose calldata is transferFrom against an approving wallet, with the minimal conditions it needs and a generated Forge test that replays it. That would have been the November 12 drain, produced in development.

The fix lives in the same few lines. Pinning venues to an allowlist, or rejecting calldata that targets token transfer functions, would have closed the route before any user approved the contract. Olympix runs at every merge and before release, so a change that widened what a route could call would have been tested the moment it landed.

Approval Is a Promise That Outlives the Trade

Aggregators earn their users' trust one approval at a time, and that trust stays parked in the settlement contract long after the trade is done. Any path that lets a stranger decide what the contract calls turns that parked trust into the attacker's balance. Teams building routers, settlement layers and intent systems carry that responsibility for as long as a single approval stays live. To see how Olympix would map the approval paths in your own settlement or routing contracts and return a working counterexample for every one that breaks, book a technical walkthrough.

On-Chain References

Exploit tx: 0x2716...732d

Settlement contract (PennysiaSettlement): 0x3aad...795e

Attacker EOA: 0x813a...8300

Attack contract: 0x96bb...a17a

Attack contract deployment tx: 0xcf2a...155f

Victim 1 (5,000 USDC): 0xf2ff...6998

Victim 2 (6.133489 USDC): 0x6108...f76a

Victim 3 (0.05 wstETH): 0x56eb...7000

Victim 4 (101,000 YUNO): 0x40a8...9497

USDC moved on by the attacker: 0x523f...56e3

wstETH bridged out: 0xbb5c...323f

See what Olympix finds on your own code

Send us a repo that's already been audited, and we'll run Olympix at the same commit and show you what comes back.