Standard ERC-20 token flows have a well-known friction problem. To authorize a smart contract to spend tokens on your behalf, you must submit an approve() transaction on-chain. That transaction costs gas. It requires the user to have ETH in their wallet before they have done anything else. It adds a step that breaks subscription onboarding UX before the user has even confirmed they want to subscribe.
EIP-2612 solves this entirely. It replaces the on-chain approval transaction with an off-chain signed message — zero gas, zero pre-funding requirement, cryptographically equivalent security. AuthOnce builds its entire authorization model on EIP-2612 permits, making subscriber onboarding gasless from day one.
The Problem With Standard ERC-20 Approvals
Before EIP-2612, every USDC subscription protocol faced the same UX problem. A subscriber wanting to authorize recurring billing had to:
Fund their wallet with ETH
Before doing anything, the subscriber needs ETH to pay gas — even if they only want to pay in USDC. This is a hard barrier for new crypto users.
Submit an approve() transaction
The subscriber sends an on-chain transaction authorizing the billing contract to pull USDC. This transaction costs gas and takes time to confirm.
Confirm the subscription
Only after approval confirmation can the subscription actually start. Two transactions, two gas fees, two confirmation waits — before the first payment.
This two-transaction flow kills conversion. Users unfamiliar with blockchain patterns abandon at the approval step. EIP-2612 eliminates steps 1 and 2 entirely.
How EIP-2612 Works
EIP-2612 introduces a permit() function to ERC-20 tokens. Instead of submitting an on-chain approve() transaction, the user signs a structured message off-chain using EIP-712 typed data. This signature encodes:
- Owner — the subscriber's wallet address
- Spender — the AuthOnce SubscriptionVault contract address
- Value — the maximum permitted USDC amount
- Deadline — the timestamp after which the permit is invalid
- Nonce — prevents replay attacks
- v, r, s — the ECDSA signature components
The signature is stored off-chain by the AuthOnce Keeper. On each billing cycle, the Keeper submits the permit signature alongside executePull(). The USDC contract verifies the signature on-chain and executes the transfer atomically.
The permit signature only authorizes transfers to the specific spender address (SubscriptionVault). It cannot be used to transfer tokens to any other address. The deadline field ensures signatures expire and cannot be replayed indefinitely. The nonce ensures each permit can only be used once in its authorized form.
// Subscriber signs this off-chain. Zero gas. Zero transactions.
const permit = {
owner: subscriberAddress,
spender: SUBSCRIPTION_VAULT_ADDRESS,
value: ethers.utils.parseUnits(monthlyAmount, 6), // USDC has 6 decimals
nonce: await usdc.nonces(subscriberAddress),
deadline: Math.floor(Date.now() / 1000) + 365 * 24 * 60 * 60 // 1 year
};
const signature = await subscriber._signTypedData(
{ name: 'USD Coin', version: '2', chainId: 8453, verifyingContract: USDC_ADDRESS },
{ Permit: [
{ name: 'owner', type: 'address' },
{ name: 'spender', type: 'address' },
{ name: 'value', type: 'uint256' },
{ name: 'nonce', type: 'uint256' },
{ name: 'deadline', type: 'uint256' }
]},
permit
);
// Keeper stores { permit, signature } off-chain.
// No on-chain transaction at authorization. Zero gas for subscriber.
How AuthOnce Uses the Permit at Execution Time
When the Keeper runs executePull() on each billing cycle, it submits the stored permit signature alongside the pull request. SubscriptionVault calls USDC.permit() to validate and execute the approval atomically within the same transaction as the transfer. The subscriber's USDC moves directly to the merchant wallet. The 0.5% protocol fee is deducted atomically.
The entire pull — authorization verification, transfer, and fee — happens in a single on-chain transaction. The subscriber signed once. They pay zero gas for the subscription authorization. The Keeper pays the (sub-cent) gas for execution on Base Network.
Permit Revocation: Subscriber Control
A subscriber can cancel at any time by revoking the permit. This is done by incrementing their nonce on the USDC contract — which invalidates all outstanding permits from that address to the SubscriptionVault. The Keeper detects the nonce change on the next execution attempt and transitions the subscription to Cancelled state. No merchant cooperation required. Revocation is unilateral and immediate.
This is a critical subscriber protection. Unlike custodial billing where cancellation requires a merchant to stop charging, non-custodial billing gives subscribers cryptographic control over their own authorization. A subscriber can always stop payments — even if the merchant does not cooperate.
ERC-1271: Extending to Smart Contract Wallets
Standard EIP-2612 handles EOA (Externally Owned Account) signatures. For smart contract wallets — Safe multisigs, ERC-4337 accounts, and AI agent wallets — signature verification requires ERC-1271. AuthOnce implements ERC-1271 support, allowing any smart contract wallet to authorize subscriptions natively. For a full treatment, see our article on AI agent payments and ERC-1271.
Contract Addresses
Base Sepolia Testnet:
SubscriptionVault: 0xeb068B47731261F7B4A5ae8535686D67D7f72321
MerchantRegistry: 0xAE681E431c353f5930dDFfBC74037d3f2afE3264
Full source via the AuthOnce developer portal. Mainnet Q3 2026.
Build gasless subscriptions on Base
EIP-2612 permits. Zero gas onboarding. Sub-cent execution. Open source contracts.