One KYC, Many Wallets: Why We Built Multi-Address Identity Linking (and Haven't Shipped It)
Most identity checks assume one address, one identity. AttestationStore is built that way today: attestations is a mapping(address => Attestation), so an address either holds a valid attestation or it doesn't, with no concept of identity above that. That assumption breaks the moment a real user shows up with more than one address attached to the same person or business - an EOA for one app, a smart account for another, sometimes several smart accounts as account abstraction (ERC-4337) wallets spread across chains and apps. Today, every new address means KYC or KYB from zero, even for someone KUMPLY already verified yesterday on a different address.
This isn't a hypothetical. It's the specific friction a candidate integrator evaluating KUMPLY flagged to us directly: their users accumulate wallets over time, and re-verifying each one from scratch is a real product problem for them, not just an abstract gap in our contracts. We're not naming them here - they haven't given explicit permission for public mention, and this post doesn't need their name to make the point. What's true either way is that we built something in response, and we're laying out exactly what it does, what it doesn't do yet, and the real limit their feedback surfaced.
A separate registry, not a bigger AttestationStore
AttestationStore and ComplianceGate are live and verified on both Fuji and Mainnet C-Chain, and the SDK, the Sumsub webhook, and the workshop issuance script all depend on today's exact verify(address) semantics. Reshaping that mapping to hold multiple addresses per identity would mean a redeploy and re-pointing every one of those consumers - the same category of pain as August's ValidatorSetManager redeploy, except this time against a contract that already holds real attestations, not a validator set that hadn't gone live yet.
So IdentityLinkRegistry.sol is a new, standalone contract. It never touches AttestationStore's storage. It answers a narrower question - do these two addresses belong to the same verified identity - and a backend process uses that answer to mirror an existing attestation onto the new address through the same, unmodified issueAttestation() call every other attestation already goes through.
How the link gets proven
Linking two addresses takes a signature from both: the address that's already verified, and the new one, each signing an EIP-712 typed message naming the other address, a nonce, and a deadline. Both signatures are checked with OpenZeppelin's SignatureChecker.isValidSignatureNow, not raw ECDSA.recover - so a smart-contract wallet using ERC-1271 (a Safe, for instance) can produce a valid signature too, not only a plain EOA private key. One address becomes the canonical identity; the registry tracks group size as a single counter instead of an on-chain array, specifically so revoking a link never costs unbounded gas as a group grows. Per-address nonces plus the EIP-712 domain (chain ID and verifying contract) stop a signature made for one chain, or one link request, from being replayed somewhere else.
Once both signatures check out, a backend process - gated by the same VERIFIER_ROLE that already gates issueAttestation() - submits the link on-chain, then calls issueAttestation() again, this time for the new address, mirroring whatever tier the canonical identity already holds. That's two separate transactions, deliberately not one atomic call: it means the registry never needs its own grant of VERIFIER_ROLE on the live AttestationStore.
What this doesn't make KUMPLY
Nothing in this design gives KUMPLY anyone's keys or funds. Both signatures come from the user's own wallets - the backend only verifies them, it never signs the link on anyone's behalf. One nuance worth being precise about, the same way we're precise about the limits of KYA elsewhere: the second step, mirroring the attestation onto the new address, runs with KUMPLY's own verifier key, not the user's signature. It only fires after both addresses have already proven the link themselves, but it's still KUMPLY's own on-chain act, not something the contract forces automatically - a policy question worth settling before this goes anywhere near production, not just an implementation detail to wave past.
Where it actually stands today
Plainly: this is built, not shipped. The contract is 319 lines with 26 passing Hardhat tests, plus a mock ERC-1271 wallet covering the smart-wallet signing path. The SDK, the API, and the dashboard frontend all have working code for it already - a wallet-linking card, a backend endpoint, read methods for the registry. None of it is deployed, not on Fuji and not on Mainnet, and no contract address exists anywhere for it to even point at. It hasn't been tested against a single real, non-mock wallet yet.
We already shared this design with the candidate integrator mentioned above, for exactly the use case described - their users rotate and accumulate wallets over time. Their answer surfaced a real limit worth sharing rather than glossing over: their users' wallets can't produce an EIP-712 signature at all, because the users themselves never hold a seed phrase to sign with. The ERC-1271 path already covers smart-contract wallets that can sign on their own - that part isn't the obstacle. The obstacle is a wallet architecture that can't sign anything by itself, and this design currently assumes both sides always can. That's a real constraint across part of the account-abstraction space, not an edge case to patch over later, and it's why nothing is deployed yet: shipping a design that can't serve the integrator who asked for it in the first place isn't a milestone worth claiming.
What's next
Before this goes anywhere near Fuji, we're evaluating a variant that doesn't require every linked address to self-sign - most likely some form of on-chain authorization from whoever actually controls the wallet, instead of an off-chain EIP-712 signature from the wallet itself. Whichever shape it takes, deploying it is a separate, explicit decision from writing the code, and we'll report it here when it actually happens instead of letting a commit speak for us.
Sources: EIP-712, typed structured data signing, ERC-1271, signature validation for contract wallets, ERC-4337, account abstraction, OpenZeppelin Contracts, SignatureChecker.