Skip to content
Help

The USDC counting rule for Arc (version 1.2.0)

How to count each movement of USDC, EURC and every stablecoin Memoline reads on Arc exactly once, checked against the balances Arc itself reports.

On Arc, USDC is the gas token, and one payment can appear in two logs. An indexer that reads every Transfer log counts some payments twice. This page is the rule Memoline uses to count each movement once. Any Arc indexer, wallet or accounting tool can use it. It is checked against real transactions, and the answers come from Arc’s own balances, not from our code.

The rule

  1. USDC moves are read from the system emitter. Every USDC transfer, mint and burn is logged as a Transfer by the virtual address 0xffffFFFfFFffffffffffffffFfFFFfffFFFfFFfE, in native units (18 decimals). This is the record to count. Gas is the one exception (rule 6).
  2. The USDC contract’s own `Transfer` is a copy, so it is dropped. A transfer made through the ERC-20 interface of 0x3600000000000000000000000000000000000000 logs a second Transfer in 6-decimal units. It describes the same movement. Count it again and the books are wrong.
  3. One exception: a transfer to oneself. A USDC transfer from an address to itself through the ERC-20 interface is logged only by the USDC contract. It is kept as a movement to itself; no balance changes.
  4. EURC, and every other stablecoin Memoline reads, moves in its own contract’s `Transfer` logs, in that token’s own decimals: 6 for EURC, MXNB or QCAD, 18 for BRLA, JPYC or ZARU. A Transfer from a contract that is not on the list of stablecoins Memoline reads is never counted, so a token that copies a real one’s name never reaches your books. The stablecoins Memoline reads are listed with their contracts.
  5. Mints come from address zero and burns go to address zero. A CCTP arrival mints USDC through the system emitter, often as two mints in one transaction: the amount, and a small fee to another address. A CCTP departure burns USDC to address zero.
  6. Gas is its own figure. The sender pays gasUsed × effectiveGasPrice in native USDC, and the fee is credited to the block’s producer (block.miner). No Transfer log records either side. Add both separately; never look for them in the logs.
  7. A reverted transaction moves nothing, and its sender still pays the gas.
  8. Memos. A payment made through Arc’s Memo contract sits between a BeforeMemo and its Memo event. The movement inside that pair, from the memo’s sender and in the memo’s token (any listed stablecoin), is the payment the memo describes.
  9. Testnet history from before the Zero5 upgrade. Before the upgrade, which reached testnet around block 44,277,200, native USDC movements were logged by 0x1800000000000000000000000000000000000000 as NativeCoinTransferred(from, to, amount), NativeCoinMinted(to, amount) and NativeCoinBurned(from, amount), in 18 decimals. Read them exactly like rule 1. The USDC contract’s copies pair with them the same way. An event from that address the rule does not know is reported, never guessed.

How it is checked

For each recorded transaction, the correct answer was read from Arc. That is every address’s balance in USDC and in every listed stablecoin at the transaction’s block, minus its balance at the block before. The addresses are everyone named in any Transfer log, plus the sender. A block where another transaction touched one of those addresses was not used, so each difference is this transaction’s alone.

An implementation is right when, for every address, its net change equals Arc’s difference. For the sender, the gas also comes off. Memoline’s test suite runs this check on every recorded transaction, thirty today.

Some wrong answers look right, so the check refuses them:

  • adding the USDC contract’s copies changes the sender and recipient balances;
  • folding the gas into the balances with a fee of zero fails, because the fee must be exactly gasUsed × effectiveGasPrice;
  • an answer that lists an address twice is refused.

Every copy the USDC contract logged must pair with a native record. One that does not is reported on the transaction, never counted.

The recorded transactions

CaseWhat it showsTransaction
Payout, 3 rowsthree USDC payments inside memostestnet
Payout, EURCEURC moved, gas paid in USDCtestnet
Revertednothing moved, gas paidtestnet
To oneself, ERC-20only the USDC contract logs ittestnet
To oneself, two more kindsno balance change apart from gasone, two
Payment linka payment from a pay pageone, two
CCTP arrivaltwo mints (amount and fee) inside an ERC-4337 bundle, and the bundler paid backtestnet
CCTP arrival, straight to the transmittertwo mints, the amount and the relayer’s feewith fee, no fee
CCTP departurea burn to address zeroplain, with hook
CCTP departure through a routerthe account pays the router, the router pays Circle’s TokenMinter, which burnsplain, in an ERC-4337 bundle
Circle Gateway deposita transfer to the Gateway Wallet and its Deposited eventtestnet
Money back from Gatewaya mint from address zero to the recipient, with the Gateway Minter’s AttestationUsed eventtestnet
Gateway nanopayment batchone BatchProcessed event; no USDC movestestnet
EURC into Circle Gatewayan EURC transfer to the Gateway Wallet and its Deposited event naming EURCmainnet
EURC back from Gatewayan EURC mint from address zero, with the Gateway Minter’s AttestationUsed event naming EURCmainnet
Before Zero5: plain transferNativeCoinTransferred onlyblock 44,276,332, 0x8471c71a…c234
Before Zero5: ERC-20 transferthe USDC contract’s copy pairs with NativeCoinTransferredblock 44,276,332, 0x59818bcc…d448
Before Zero5: CCTP arrivaltwo NativeCoinMintedblock 10,006,728, 0x09def603…6984
Before Zero5: CCTP departureNativeCoinBurnedblock 10,000,729, 0xafb9f87a…8115
Mainnet payoutthree USDC paymentsmainnet
MXNB, 6 decimalsMXNB paid into Circle’s StableFX escrowtestnet
QCAD, 6 decimalsQCAD settled out of the StableFX escrowtestnet
BRLA, 18 decimalsBRLA settled out of the StableFX escrowtestnet
ZARU, 18 decimalsZARU paid into the StableFX escrowtestnet
A Memo payment in MXNB, simulated1 MXNB inside a memo; simulated on testnet state, not mined, because no Memo payment in a partner stablecoin exists on Arc yetnot mined

All thirty match Arc with this rule. The public testnet RPC no longer answers the four oldest hashes directly; their receipts are read from their blocks (eth_getBlockReceipts).

See it on any transaction

GET /api/v1/tx/{hash} returns, next to the ledger lines, participants (each address’s exact net change as an integer string, with its unit) and checks (the rules applied and how many times). The transaction page shows the same under "Every address in this transaction". See the API and agents guide.

Versions

  • 1.2.0 (2026-10-08): every stablecoin Memoline reads on Arc is counted from its own contract in its own decimals (rule 4), and a memo attaches to a movement of whichever of them it names (rule 8). Recorded proof in MXNB, QCAD, BRLA and ZARU.
  • 1.1.0 (2026-09-24): reads testnet history from before the Zero5 upgrade (rule 9); says where the gas fee goes (rule 6); replaces the "adds up" check, which could not fail, with a real one: every USDC contract copy must pair with a native record.
  • 1.0.0 (2026-09-24): first version.