Smart accounts & account abstraction

Your MozaikPay wallet isn't a classic crypto account. It's a smart account, a small program that lives on Base, holds your digital dollars, and defines its own rules for moving them. This page explains what that means and what it makes possible.

The classic account

On Ethereum-style networks, the basic account is nothing more than a key pair. The address is derived from the key, and the network applies a single fixed rule. An instruction with a valid signature from that key can do anything, and an instruction without one can do nothing.

That simplicity is where most of crypto's sharp edges come from. The key is the account, so it can never be changed, and anyone who learns it owns the money, permanently. There's no spare, because the network recognizes exactly one key, and every account pays its own network fees, in the network's own coin, no exceptions.

Accounts made of code

Account abstraction replaces that fixed rule with one you can write. Under a standard called ERC-4337, an account can be a contract, a program on the network that holds funds and decides for itself which instructions are validly authorized. How it decides is up to the code inside.

The shift sounds technical, and it changes everything about how a wallet can behave. Keys stop being the account and become credentials the account recognizes, which means they can be limited to certain jobs, and they can be replaced.

What our account does with that freedom

Two keys with different powers. The account recognizes a spending key and a recovery key, and it checks which one signed each instruction against what the instruction asks. Payments need the spending key, key changes need the recovery key, and a wrong pairing is rejected by the network itself. The two-key model explains why the jobs are divided this way.

Locks that can be changed. Because keys are credentials rather than the account itself, losing a phone means rotating one key, not abandoning the wallet. Your address, balance, and history stay exactly where they are while a fresh spending key takes over.

Fees someone else can pay. A smart account's network fees can be covered by a sponsor. We cover yours, which is why you never hold ETH and never see the word gas. Gas sponsorship explains the machinery.

Money that can wait. A payment link needs somewhere for the money to sit until it's claimed. It waits in a small companion contract that can do two things, pay whoever holds the link or return the money to you, and nothing else, no matter who asks.

Deliberately small

Code-defined accounts cut both ways. A contract can encode any rule, which means it could also encode a bad one, an admin role, a hidden override. The protection is minimalism and openness. Our account contract does the few things listed above and nothing else. It has no owner, no pause switch, and no function reserved for MozaikPay. The source code is public on GitHub, and the deployed contract sits on Base for anyone to verify.

Accounts can be upgraded as the design improves, and that power belongs to your recovery key alone. We can publish a better version of the contract, and only your key can move your account onto it.

Instructions reach your account signed on your phone and delivered through the network's shared machinery. Onchain transfers follows that path end to end.