Picture a marketplace with a wall of lockers. You're selling a bike to a stranger. You lock it in an empty locker and write your price on the door: 40 coins.
The locker only knows two moves. If someone pays 40 coins, you get the coins and they get the bike in the same moment. If nobody pays, you take the bike back. There's no move where the buyer rides off and you get nothing.
One more detail. The locker is free, but it takes up space on the wall, so you leave a small deposit while it's in use. When the locker is emptied, the deposit comes back.
That's an escrow, and it's what we built for Deed #3 on Solana's test network, devnet. Deed #1 sent tokens. Deed #2 set a token's rules. This time two people swap tokens and neither has to trust the other.
Who holds the bike while you wait?
On Solana the seller is the maker and the buyer is the taker. The locker is two accounts.
The offer account is the note on the door. It records who made the offer, which token is locked, which token is wanted and the price.
The vault is the inside of the locker: a token account holding what the maker locked.

The vault belongs to an address that has no private key. Only the escrow program can sign for it, and the program only moves what's inside when someone takes the offer or the maker asks for a refund.
How do you build a locker with no key?
The title of this post depends on it, so here's how it works.
An ordinary Solana address, like your wallet's, is a public key. Mathematically it's a point on a curve called Ed25519. Every point on that curve has a matching private key, and whoever holds that key can sign for the address.
A locker with a private key would be a locker someone could empty. So Solana lets a program make addresses that are deliberately not points on the curve. If the address isn't on the curve, no private key for it can exist.
The recipe goes like this. The program mixes a few ingredients with its own address and hashes them. Ours are the word escrow, the maker's address and an offer number. Out come 32 bytes that look like an address. Roughly half the time those bytes happen to land on the curve, which is no good. So one more ingredient goes in, a single number called the bump. It starts at 255. If the result lands on the curve, try 254, then 253, and keep going until it lands off. The first number that works is the one everybody uses.
Both of our devnet offers landed off the curve at 255, first try. I checked what the same maker's third offer would have needed: 253, because 255 and 254 both land on the curve. Across offer numbers 1 to 200 for that maker, 113 work at 255 and 45 need 254.
Anchor does the search when the offer is made. That's the lone bump in this part of the program:
#[account(
init,
payer = maker,
space = Escrow::DISCRIMINATOR.len() + Escrow::INIT_SPACE,
seeds = [ESCROW_SEED, maker.key().as_ref(), &seed.to_le_bytes()],
bump,
)]
pub escrow: Account<'info, Escrow>,
We store the answer in the offer account so the later steps don't have to search again.
When a taker pays, the program has to move tokens out of the vault. It can't sign with a key, because there isn't one. It hands Solana the same ingredients and the stored bump:
let bump = [self.escrow.bump];
let signer_seeds: &[&[&[u8]]] = &[&[ESCROW_SEED, maker.as_ref(), &seed, &bump]];
Solana runs the recipe again with those ingredients and the address of the program that's asking. If the result is the offer's address, the program may act for it, and the offer's address is the one in charge of the vault. No other program can get that match, because the program's own address is one of the ingredients.
The vault is built the same way one level down. Its address is derived from the offer's address and the token, with a bump of its own.
So "nobody holds the key" is literal. There's no key to hold.
Why the locker needs a deposit
Everything on Solana lives in an account: our program, each offer, each vault. Every account takes up space that the whole network has to store, so each one holds some SOL for as long as it exists. Solana calls this rent. It works like a deposit: close the account and the SOL comes back.
A bigger account needs a bigger deposit. Our program is 252,000 bytes and holds 1.28 SOL. An offer is 121 bytes and a vault is 165. When our first swap finished and both closed, 0.00275336 SOL went back to the maker.
What the receipts show
Watch the Deed #3 demo on YouTube.
On devnet the maker locked 100 of test token A and asked for 40 of token B. That's the make. The taker paid 40 B and received all 100 A in one transaction, the take. The vault and the offer closed in that same transaction.
Then we tried to underpay. A second offer asked for 60 B and our taker had 10. We signed the take and ran it as a simulation, so nothing was sent. The program answered InsufficientTokenB (6001) and the vault still held its 50 A. The maker took those 50 A back with a refund.
One gap turned up at review. Nothing stopped someone offering token A in exchange for token A. We added a check and a test for it; the test failed before the check went in.
What we built it with
The program is Rust, using Anchor. Anchor writes the repetitive account checks for us: is this the right signer, does this account belong to this program, was this address derived the way we expect. You'd pick something leaner, like Pinocchio, when you need to squeeze every bit of compute. That's planned for a later deed.
Everything outside the chain is TypeScript. Codama reads the program's interface and generates a typed client. Solana Kit builds and sends the transactions. The build fails if the committed client differs from a freshly generated one, so the two can't drift apart.
We tested with LiteSVM, which runs the program inside the test itself. It's fast, and you create every account yourself. Surfpool is a local stand-in for a network: use it when your app calls an RPC or needs accounts that already exist on mainnet. Our escrow only needed tokens we made ourselves, so LiteSVM was enough, and we didn't run Surfpool for this deed. The escrow has 24 LiteSVM tests and the client has 7.
Three briefs instead of one long chat
Claude Code did the build in three stages, each a separate session with a written brief: the pinned toolchain, the escrow, then the devnet deployment and the notes for a reviewer. The first deployment attempt didn't land over the public devnet RPC. The session closed the half-written buffer, got its 1.28 SOL back and tried again.
By the third deed we were repeating the same instructions at every kickoff, so we wrote the routine down. The playbook is public and now sits in the 17 remaining deed repositories. Nobody outside the session that wrote it has run it yet. Deed #4 is the test.
The first cut of the video ran two minutes and skipped the deposit. I asked for the rent explanation, the libraries and the locker with no key, which is why this one runs four minutes. The first cuts used a synthetic voice. I recorded this one myself, scene by scene.
What's still open
No real wallet has touched this. The tokens are test tokens we minted on devnet. One key of ours can upgrade the program. That's fine for a demo and wrong for anything holding value, because whoever can upgrade the program can change what the locker does.
Two more limits are worth knowing about.
Someone can take your locker number. Every offer's locker sits at an address anyone can work out ahead of time, because the address is calculated from the maker's own address and an offer number the maker picks. Solana lets anyone set up a token account at an address like that, as long as they pay its deposit. So a stranger who guesses your next offer number can set one up there before you do. Our program expects to create the locker itself, finds one already there and refuses your offer. The stranger can't open that locker and gets nothing of yours, and the deposit comes out of their pocket. You pick a different offer number and try again. It's a nuisance, and nobody loses tokens.
Some tokens come with an off switch. Whoever issues a token can keep what Solana calls a freeze authority: the power to stop one particular account from sending or receiving that token. Some issuers keep it so they can block stolen funds. Our program can't override it. If a token in a swap has one and the issuer freezes the locker or one of the traders' accounts, the swap fails until the account is unfrozen. We made our test tokens without a freeze authority, so the demo never ran into this.
Deed #4 is a swap page built on Jupiter.