Ethereum Credit Cards

I just read The Divide by Matt Taibbi. Among many other horrors, he describes in chapter eight the collections process on delinquent credit cards, focusing in particular on abuses revealed by a whistleblower at Chase.

Banks looking to raise quick cash will often sell delinquent accounts to a company that will attempt to collect. The buyer wants accounts with actual judgements against them, meaning the bank took the borrower to court and a judge said the money was actually owed. The whistleblower found that many of the "judgements" sold by Chase were not actually valid. In some cases the cardholders weren't even delinquent. In others, Chase actually owed the cardholders.

Of the valid judgements, many were never contested by the cardholder, because they never knew they were being taken to court. As you've seen in the movies, you're supposed to be "served." The banks were serving people by, for example, sending postcards to old addresses. They pay bulk rates to companies that do the crappiest job they can get away with, because if banks had to actually pay lawyers to take every debtor to court, credit cards wouldn't be a profitable business. It's better for the banks if debtors never show up. In some cases, the process servers even throw away the summonses they're supposed to serve, but swear that they properly served the debtor.

Debtors who don't show up to court lose by "default judgement." If they get the summons, they often just assume the bank is correct and pay the supposed balance. If they show up in court, they often don't bring evidence.

But if they actually contest the case, the bank has to dig up old documents; or, if the bank has already sold the debt, the collector is in trouble, because the banks intentionally don't include all the documentation. If the collector needs more paperwork, the bank sells it to them. Often at this point the collector will simply drop the case.

But it seldom gets that far. According to Taibbi, "the bulk of the credit card collection business is conducted without any supporting documentation showing up or being seen by human eyes at any part of the the overwhelmed modern court system, simply attesting to having the right documentation works just as well as really having it."

According to one judge, "On a regular basis this court encounters defendants being sued on the same debt by more than one creditor alleging it is the assignee of the original credit card obligation."

Once there's a real judgement, collectors can do just about anything: attach salaries, put liens on property, or even confiscate cars and furniture. Some people don't even know they have a judgemnt against them, until they try to sell their house.

Fixing This

To anyone familiar with blockchains, all this has to seem completely insane. We have immutable public records now. We don't have to put up with this nonsense.

Put credit cards in a smart contract. Pay out loans through the contract, and take payments through it. Anyone can check and see whether payments are due. Put a nice UI on it and a judge can just check all the records on a laptop. We ensure accuracy, but we also make court less expensive.

Of course, we can't put people's names, birthdates, and SSNs on the blockchain. Instead, the bank puts that stuff plus a random salt in an identity document, and hashes it. The hash goes on chain. To take a borrower to court, the bank reveals the preimage in closed session; the court checks that it matches the hash, and takes that as evidence that the account matches the real-world identity.

The bank would also need to produce the original paper application, signed by the borrower, giving the bank the right to collect. If the preimage doesn't match this document, the debt is invalid. The borrower could write is Ethereum address on the application, using a BIP39 list of words. Alternatively, the borrower could import the identity hash into an app, and associate it with an address by sending the hash to the lender contract.

We can add events for summonses and judgments, publishing hashes of documents hosted on Swarm. As long as the borrower is still monitoring the contract, he'll be informed of legal actions.

Here's a contract:

contract Lender is owned {
    event logLoan(address indexed borrower, uint amount);
    event logPayback(address indexed borrower, uint amount);
    event logTerms(address indexed borrower, uint limit, uint rate, uint minimumPercent, uint minimumPayment);
    event logSummons(address indexed borrower, bytes32 contenthash);
    event logJudgement(address indexed borrower, bytes32 contenthash);

    mapping (address => uint) public limit;
    mapping (address => uint) public loaned;
    mapping (address => bytes32) public secretIdentity;

    function setIdentity(address borrower, bytes32 ident) onlyOwner {
        if (secretIdentity[borrower] == address(0)) throw;
        secretIdentity[borrower] = ident;

    function summon(address borrower, bytes32 hash) onlyOwner {
        logSummons(borrower, hash);
    function judge(address borrower, bytes32 hash) onlyOwner {
        logJudgement(borrower, hash);

    function setTerms(address borrower, uint limit, uint rate, uint minimumPercent, uint minimumPayment) onlyOwner {
        //no loans to anyone who doesn't have identity set
        if (secretIdentity[borrower] == address(0)) throw;
        if (limit < loaned[borrower]) throw;
        limit[borrower] = limit;
        logTerms(borrower, limit, rate, minimumPercent, minimumPayment);

    function withdraw(uint amount) {
        if (loaned[msg.sender] + amount > limit[msg.sender]) throw;
        loaned[msg.sender] += amount;
        logLoan(msg.sender, amount);
        if (!msg.sender.send(amount)) throw;

    function payback() payable {
        uint val = msg.value;
        if (val > loaned[msg.sender]) {
            val = loaned[msg.sender];
        logPayback(msg.sender, val);
        loaned[msg.sender] -= val;
        if (val < msg.value) {
            if (!msg.sender.send(msg.value - val)) throw;
    function () onlyOwner payable {}
    function ownerWithdraw(uint amount) onlyOwner {


There's an interesting side effect of all this. To avoid losing money, the lender has to do sufficient identify verification of borrowers. This means any address in the Lender contract can be generally trusted to have some kind of real-world identity. You can even get a rough estimate of the lender's confidence, by looking at the credit limit. It's not impossible for someone to have more than one account with the lender, but the lender is probably going to limit that too. They could have accounts with multiple lenders, but the lenders have an incentive to share identity documents so they can see how much debt a person has.

I always thought we'd need good identity verification before we can have loans on the blockchain. But actually, by putting loans on the blockchain we can get identities.

Having mostly sybil-proof identities would let us do all sorts of other cool stuff, like voting systems that really give us one vote per person, instead of having to weight votes by account balances all the time.


The above contract just pays money directly to the borrower, who has to initiate a separate transfer to make a purchase. We don't actually need two transfers; we can add a function that lets the user send money directly from the lender contract to a merchant.

We can even add a bytes32 field to this method, so we can integrate with serverless shopping carts. This means we have to change the shopping cart contract in the last post, so it can accept a purchaser address as a parameter, instead of just using msg.sender directly. Otherwise, the "purchaser" will just be the lender contract.

The Future

For now, we aren't at credit card scale, but we might be soon. The first version of sharding is supposed to handle 1,000 to 10,000 transactions per second. VISA only does about 4,000 on a normal day (though an order of magnitude more during holidays).

By the time we actually achieve that level of usage, courts should be more familiar with the concept of evidence on the blockchain, and consumers should be relatively unintimidated by the technology.

To make it all work, we need better privacy on payments. Just because you pay someone with a credit card, doesn't mean you want them to see your credit limit, outstanding balance, and entire payment history. Luckily, better privacy is on the way too.