Skip to main content

Spend and Collect Without Exposing Your Hand: Solving the Last-Mile Privacy Dilemma of DID with ValueCard Aggregation and Bridge Dual-Signature

Robert Mao
Everything is ContextVerifiabilityArchitectureSecurityDIDDID WalletArcBlock ChainBlockchain

Since the day we designed the ABT DID protocol eight years ago, one rule has anchored our identity architecture: every time a user visits a new website or Blocklet application, their wallet automatically derives a separate, cryptographically independent identity (DID_App1, DID_App2, DID_App3). Looking strictly at public keys and login credentials, no two applications can correlate who you are.

Yet for a long time, an unresolved architectural tension stayed on our minds: identity isolation works beautifully at the login layer, but the moment a real token transaction happens on-chain, whether you are spending money as a user or collecting revenue from multiple apps as a developer, that privacy can collapse in a single hop.

Think about why. You may use fifty different derived DIDs across fifty applications, and most of those services will eventually charge fees. Where does the money you spend come from? Nobody maintains fifty unrelated external funding sources just to use fifty apps. As soon as your spending funds originate from a single bridged wallet (0x address) or a single main treasury, anyone inspecting the ledger can draw a simple star graph and link every one of your application identities in seconds.

In our latest architectural design, we finally closed this loop: by unifying one-time dual-signature Bridge delegation with our native ValueCard voucher clearing engine, we keep normal 0x transfers 100% plaintext and frictionless while solving three hard problems at once, Apple Pay-style unlinkable spending, one-click composable checkout across dozens of prepaid cards and coupons, and Stripe-style revenue isolation for multi-app developers, backed by four protocol-level compliance locks that make the system structurally unusable for money laundering or crime.

Rather than walking through low-level cryptographic equations, this article explains the engineering logic, user experience, and legal boundaries behind this design for developers and technically minded users.

1. Why Multi-DID Privacy Breaks Down the Moment You Spend or Earn Money

To see why this problem has haunted decentralized identity systems for years, walk through what actually happens when an everyday user spends tokens on-chain, and when an independent developer collects revenue from profitable apps.

Start with the spending side. Many users keep their primary holdings in a standard Ethereum wallet like MetaMask (a 0x address) and bridge tokens into ArcBlock Chain when needed. Because ArcBlock Chain natively supports 0x account formats 1, a bridged address maps directly onto the chain in plaintext.

Now suppose your wallet has derived twenty different per-application DIDs (DID_App1..20) and wants to pay for services in each of them. Immediately, you hit three exposure funnels:

  1. The Funding Fan-Out Funnel: You have one (or a couple) bridged 0x addresses, but dozens of scattered app DIDs. If your 0x account transfers funds directly to those twenty app DIDs, the ledger permanently records twenty outgoing edges from a single root. Every persona is linked in one hop.
  2. The Zero-Gas New DID Deadlock: Even if you don't pre-fund each child DID with a large balance, a freshly derived DID_App starts with zero balance and cannot even pay the txGas for its first transaction. If your main wallet steps in to sponsor its Gas directly, the transaction header explicitly names your main wallet as the payer.
  3. The Naive Delegation Funnel: We previously explored using account delegation (Delegate) so a bridged 0x address could authorize child DIDs to spend on its behalf. But under a traditional plaintext delegation model, every payment still draws from that single public delegation channel. Any observer watching the channel immediately sees which child DIDs belong to the same root account.

Why Multi-DID Privacy Breaks on Payment: From Star Funnels to ValueCard Clearing

While working through this design, we also ruled out several popular ideas that sound appealing on the surface but fail in practice:

  • Why not ask users to import their MetaMask private key into DID Wallet? Asking users to export and import raw private keys across wallets increases their security risk. Moreover, turning DID Wallet into a kitchen-sink Ethereum wallet just to support every external Ethereum dApp protocol makes no engineering sense when ArcBlock Chain already supports 0x accounts natively. The right boundary is letting the user's Ethereum wallet sign with Ethereum's native mechanism while DID Wallet handles DID operations.
  • Why not use Stealth Addresses (EIP-5564) or single-user isolated pools? Stealth addresses only hide the recipient when someone else sends you money. Here, the sender funding your app DIDs is your own main wallet! Even if every child DID were a stealth address, the on-chain graph still shows your main wallet funding all twenty stealth addresses. And giving each user a private pool of their own yields an anonymity set of 1, hiding nothing.
  • Why not pack child DIDs into a static Merkle tree for batch delegation? Two fatal flaws: first, per-app DIDs are derived dynamically in the future whenever you visit a new service, so you cannot know the full list at the moment you sign in MetaMask; second, if multiple child DIDs prove membership against the same account's Merkle root when spending, observers still link all of them to that shared root.

Now flip to the earning side, which matters just as much for builders.

Suppose you build and run five independent Blocklet applications, and two of them become highly profitable. Within a single application (App_1), having transparent on-chain revenue is great for customer trust. What is unacceptable in normal business is having a competitor trace a single profit-collection transfer from App_1 back to your master 0x treasury, and immediately uncover App_2, App_3, and every other profitable business you operate. In the physical world, eating at a busy restaurant does not give you the right to look up the owner's tax ID and inspect every other company they own. Without revenue-collection isolation, public blockchains force every entrepreneur to expose their entire business portfolio to competitors.

2. Spending Money: Bridge Dual-Signature, Plaintext Freedom, and Composable Checkout Across 10+ ValueCards

To break the funding fan-out and delegation linkage without adding friction, our core architectural move is unifying Bridge spending delegation (Delegate) with our native ValueCard (stored-value voucher) clearing primitive.

Before looking at how vouchers work, one product rule is non-negotiable: privacy must never take away a user's freedom to make normal plaintext transfers.

If a user bridges tokens onto ArcBlock Chain and discovers their money is locked inside an opaque shielded pool where they cannot even send a normal transfer to a friend, the user experience is broken. In our design, your bridged 0x account remains a 100% normal plaintext account by default. Whenever you want to make a standard transfer, it executes in plaintext immediately. The ValueCard / Voucher state only engages at the moment you actually spend inside an application or settle commercial revenue.

Here is how the spending flow works end to end:

1. One-Time MetaMask EIP-712 + DID Wallet Dual-Signature Unlocks Unlimited Derived DIDs

You never export your MetaMask private key, and you never have to pull out MetaMask to sign every time you visit a new app.

To enable private spending across all your apps, you perform a one-time dual-signature binding: one signature from your Ethereum wallet (using standard human-readable EIP-712 typed data) and one signature from your DID Wallet (via AUP).

Instead of recording a public 1-to-1 link between your 0x address and a list of child DIDs, this dual-signature stakes a spending allowance into the chain-wide, 100% plaintext-auditable Stake-for-Card reserve pool. Here lies a crucial cryptographic separation: the rolling daily safety cap is enforced on the Issuance side, while unlinkable privacy operates on the Redemption side. Whenever the delegation channel replenishes or mints blinded ValueCard notes from your 0x allowance into the global commitment pool, the chain strictly enforces your daily rolling cap (so even if a hot delegate key were ever compromised, the maximum value it could draw in a day is hard-capped). Once those blinded voucher notes are minted into your wallet, when your dynamically derived DID_App1 and DID_App2 spend them at merchants, verification checks only the chain-wide global Stake-for-Card commitment root and a one-time nullifier, never touching a per-user counter at spend time. Merchants and chain observers can verify in milliseconds that the voucher is 100% backed and unspent, without ever linking two spends back to the same daily cap counter or root wallet.

2. The Huge UX Dividend: Combining 10 Prepaid Cards, Coupons, and Balance in a Single Tap

Unifying Delegate channels with ValueCard vouchers in this architecture also unlocks a major user-experience breakthrough that solves one of the most annoying problems in digital payments.

Composable Checkout: Combining 10 ValueCards, Coupons & Balance in One Click

Think about what accumulates inside a real user's wallet over time: you join community events, claim hackathon rewards, buy prepaid bundles, and end up holding ten different ValueCards with small leftover balances, three promotional Coupons with expiration dates, some app service credits, plus your own main balance.

When you go to pay a 25-unit bill today, forcing you to manually figure out "Which card has enough balance left? Card #3 only has 3.20 left, how do I use it up?" is terrible UX. In almost every existing system, those small leftover card balances become unspendable dust.

Because promotional Coupons, prepaid ValueCards, and on-demand delegation allowances all share the exact same Composable Voucher primitive in our protocol design, the wallet checkout engine can perform single-transaction atomic aggregation:

  1. Zero mental overhead, optimal automatic ordering (with re-blinded change notes): You tap confirm once. Locally, your wallet automatically selects expiring promotional coupons first (say, 5.00), sweeps the leftover dust from two old ValueCards (3.20 and 6.80) down to zero, and draws a single exact top-up voucher (10.02, including 0.02 for txGas) from your dual-sig reserve to settle the entire bill in one atomic transaction. Crucially, partially spending a ValueCard never decrements a static public card ID in place; instead, like a UTXO note split, spending part of a card nullifies the old note and atomically mints a freshly blinded change note. That means sweeping those 3.20 and 6.80 leftover change notes today carries zero link back to the earlier merchants where those cards were first partially used.
  2. Clean sweep for the user, single clean payment for the merchant: You never have to juggle cards or leave stranded dust behind; the merchant receives one clean, 100% reserve-backed settlement; and neither the merchant nor outside observers can see which cards or root wallet funded the purchase.

3. Collecting Money: Stripe-Style Revenue Isolation and the Provenance-Gated Bridge Lock

We apply the exact same symmetry to the other side of the ledger: collecting business revenue and withdrawing funds across the Bridge.

If consumer spending works like Apple Pay (using tokenized card credentials so merchants cannot track your primary bank card), merchant revenue collection works like Stripe.

When a developer operates multiple profitable Blocklet applications (App_1, App_2, App_3):

  • Inside each individual application, customer payments and receipts remain verifiable on-chain;
  • When the developer collects profits across those apps, App_1 and App_2 never send plaintext transfers directly to the developer's master 0x treasury. Instead, merchant revenues settled via verified ValueCard vouchers are delivered into the protocol's Commercial Clearing Pool in exchange for blinded settlement receipts;
  • When those settlement receipts are redeemed into the developer's treasury, anyone on-chain can verify that the funds came from legitimate, settled commercial activity, but competitors cannot trace App_1 across the ledger to discover App_2 or map out the developer's business empire.

Even more importantly, this pairs directly with a hard security gate on the cross-chain Bridge: Provenance-Gated Bridge Withdrawals and Global Quota Conservation.

Most cross-chain bridges make a dangerously naive assumption when a user requests a withdrawal back to Ethereum: "If this address currently holds X tokens in its balance, let it withdraw X tokens." If an attacker ever compromises a hot key, exploits an app contract, or sweeps unbacked tokens into an address, they can drain the entire bridge liquidity pool in one transaction.

In our design, the Bridge never allows a withdrawal simply because an address holds a raw token balance. Every cross-chain exit must pass a strict on-chain provenance check:

Per-Account Max Bridge Withdrawal ≤ Unwithdrawn Bridge Deposit Principal + Matured Verified Commercial Revenue Global Bridge Exit Quota (Σ Merchant Exit Quotas + Σ Remaining User Deposit Quotas) ≡ Total Net Verified Bridge Deposits

A sharp security auditor reading that formula will immediately ask: "What if a hacker exploits a bug to obtain unbacked tokens on-chain, registers a fake merchant App_Evil, and wash-trades with themselves to turn stolen tokens into 'Verified Commercial Revenue' that can exit the Bridge?"

That attack fails completely because the Commercial Clearing Pool only accepts closed-loop ValueCard vouchers backed by upstream Deposit provenance. When a customer spends a 10-unit ValueCard at a merchant, the protocol transfers 10 units of existing upstream Deposit-backed exit quota 1 from the payer's reserve pool to the merchant's clearing receipt. Commercial transactions never mint new Bridge exit quota out of thin air. This delivers two critical guarantees at once:

  1. Blast-radius containment against hacks and wash-trading: Delegated spending channels are already capped at issuance by daily rolling limits and barred from calling Bridge withdrawals. Even if an attacker obtains raw tokens that lack upstream deposit provenance, those tokens cannot mint ValueCards and cannot enter the Commercial Clearing Pool via a fake merchant (App_Evil) to manufacture exit quota. At the Bridge gate, their withdrawable quota remains strictly zero.
  2. Full exit rights for legitimate builders: A developer who bridged only a small initial balance from Ethereum, but earned substantial revenue by running real applications on ArcBlock Chain, has their verified commercial settlement receipts (after a standard dispute maturity window) automatically credited toward their provenance-backed withdrawal quota. Every unit of honest revenue can exit cleanly.

4. The Clear Line Between Legality and Crime: Why This Architecture Cannot Become Tornado Cash

Any developer or compliance officer reading this will naturally ask the most important question of all: If your system prevents outsiders from linking cross-app payments and revenue collection, is it legal? Could hackers abuse it to launder stolen funds and turn privacy into a regulatory liability?

Our position is unequivocal: we will never build an open money-laundering mixer, and we will never let privacy become a source of legal liability or a shelter for cybercrime. From its first design principle, this architecture is engineered to provide commercial privacy that is structurally unusable for illicit mixing.

To see why, compare our architecture side by side with Tornado Cash, Bitcoin CoinJoin, and Zcash:

Commercial Privacy vs. Mixers: Comparison with Tornado Cash, CoinJoin & Zcash

DimensionTornado Cash (Open Mixer)Bitcoin CoinJoin (Multi-Party Mix)Zcash (Global Shielded Pool)ArcBlock ValueCard + Provenance Gate
Core PurposeLet anyone move large sums anonymously to arbitrary third partiesCombine UTXOs from strangers into a single shared transactionMove tokens from transparent addresses into an opaque z-addr poolShield users from cross-app profiling & shield builders from competitor spying
Can It Launder Funds to Arbitrary Third Parties?Yes (a hacker deposits stolen funds and hands the note to an accomplice to cash out)Yes (mixed outputs can be sent to any external address)Yes (unrestricted peer-to-peer transfers inside the shielded pool)Structurally Impossible: consumer vouchers only pay on-chain Gas or registered merchants; no third-party cash-out
Can Stolen Millions Cash Out Through It?Yes (uncapped large pools with zero provenance verification)Yes, plus severe taint contagion (one hacker in a batch taints every honest user's UTXO)Yes (no commercial clearing boundary, leading to widespread exchange delistings)No: consumer vouchers have rolling micro-caps; Bridge exits require verified deposit + matured merchant revenue
Reserve & Supply AuditabilityOnly total contract balance is visible; inflows/outflows are a black boxOn-chain UTXO graph is visible, but coordinators face criminal prosecutionBoundary turnstiles track net pool balance, but in-pool note commitments are opaque; circuit soundness bugs risk undetected in-pool counterfeiting100% Plaintext Auditable: Stake-for-Card reserve is plaintext & zero-burn; users hold local Viewing Proofs

Once you compare the mechanics, the legal and structural dividing line is crystal clear.

A protocol becomes a money-laundering engine like Tornado Cash only when it opens three doors at once: first, allowing funds to be transferred anonymously to arbitrary third-party cash-out addresses; second, allowing uncapped million-dollar inflows and outflows; third, erasing provenance so no one can verify clean origin.

Our architecture bolts all three doors shut at the protocol layer:

  1. Closed-Loop Utility on the Consumer Side: The ValueCard vouchers drawn from Stake-for-Card are functionally and legally equivalent to an Apple Pay tokenized card number or a closed-loop Starbucks stored-value card. They can only pay on-chain txGas or settle purchases at registered ecosystem merchants and Blocklets. They cannot be transferred to an arbitrary third-party address or cashed out into free-floating external tokens. A hacker sitting on $10 million of stolen funds has zero use for a capped closed-loop app voucher.
  2. Zero "Taint Contagion" Unlike CoinJoin: In Bitcoin CoinJoin, if you mix your honest UTXO in a batch where one participant happens to be a criminal, compliance engines flag every output in that transaction as tainted. In our system, users never mix raw transferable coins with strangers, and every Bridge withdrawal is strictly gated by that account's own verifiable deposit history and verified commercial receipts. Illicit funds cannot enter the exit quota, and honest users are never tainted by strangers.
  3. 100% Plaintext Reserve Conservation + Selective Viewing Proofs: Unlike Zcash's opaque shielded pool, every token backing a ValueCard sits in a 100% plaintext, publicly auditable Stake-for-Card state on-chain with zero token burn, eliminating any risk of hidden inflation. And because every voucher is deterministically derived from your wallet seed and backed up encrypted in your personal ArcSpace, you always hold a complete personal ledger. Whenever you need to prove to a tax authority, a merchant, or a compliance auditor that a specific payment came from your own clean main wallet, you can generate a local Selective Viewing Proof for that exact transaction without exposing any of your other derived DIDs.

5. Returning to Common Sense: Commercial Decency, Not a Lawless Black Box

Stepping back, this design ties together the central thread running through our entire blockchain architecture series: in Re-reading Our 2020 Essay "What Is a Token?", we explained why tokens are structured engineering building blocks rather than speculative chips; in Per-User Dynamic Gas Quotas and Three-Level Gas-Free Staking, we showed how to eliminate Gas friction for everyday users; and with this design, we finally solve the last-mile dilemma of how money can be spent and collected across derived DIDs without exposing your entire financial graph.

Notice that we did not need to invent an exotic ideological narrative to get here. All we did was bring the most time-tested commercial common sense from the everyday world onto the blockchain:

  • When you make a normal transfer from your bank account (0x plaintext account), it stays open, direct, and unrestricted;
  • When you tap to pay at twenty different stores (in-app spending), it works like Apple Pay, hiding your master account number from merchants while automatically combining your expiring coupons and leftover gift cards in a single tap;
  • When you run multiple profitable shops (developer revenue collection), it works like Stripe, keeping each shop's books clean while preventing competitors from using one receipt to spy on every other business you own;
  • And when funds cross the border back through the Bridge, they clear strictly against verifiable deposit principal and legitimate commercial settlement receipts, leaving zero room for hackers or money launderers.

Real privacy was never about building a lawless darknet for criminals. It is about giving law-abiding users and honest developers the everyday commercial decency and security they already expect in the real world. After years of wrestling with this dilemma, we finally have an architecture that gets all four pieces right at the same time.