You can have a Game Card — a card that’s denominated in the in-game currency. It’s not pegged to anything; it’s just something you can use. And you don’t really need to mark it to market, because it’s just the native currency. So, you can use the CARD Protocol for usage billing and the underlying SSC as a way to measure it.

Many new users want to use dApps, but don’t have any Ether, so they can’t pay gas. A dApp can provide a Gas Card — that’s just like a card for you to fill up your gas if you’re doing delivery for a company. This allows the users to be subsidized, to have a certain amount of Gwei to use over time. But you’re not giving the person Ether. This is non-transferable; the amount can only be used through meta-transactions and other types of funding mechanisms, where we are only going to pay people who are providing transactions and putting things on mainnet, for example. You can’t just sign up for 100 accounts and get several Gas Cards to accumulate a nice number of ETH. This is a non-transferable spend-for-transaction-only Gas Card. It could be implemented in different ways, with meta-transaction relayers; and we’re also working on something called “transaction refueling,” which basically means that we deposit in an address that is multi-sig-controlled.

Someone could sell you such a card, but it could also be a gift as part of a free trial. The Free Trial Card can be denominated in the local token. This would be similar in concept to what companies and entities and protocols are trying to do — how could people try out your service without having tokens? This would be another non-transferable way of doing it; so, they can’t trade or sell it, they can only use it to redeem services. It’s about this idea of signing up and then getting a balance that is non-transferable, using the CLUTCH mechanism — it can only be spent for services, it cannot be extracted or withdrawn in a more traditional token way. This could be a good way to make sure that people don’t pull these tokens together for financial gain, but actually try out the service and learn what the network means.

On the other hand, when customers or workers (people who are working in your network) are doing something very valuable — facilitating usage, facilitating the network — they can be given a Reward Card. This reward is something that is earned with action; it’s what we call “quantifiable work.” It’s about thanking someone for their work through an extra bonus. And that can actually be something that can be redeemed directly in the network. So, you can use these earned rewards almost like a credit card reward to earn more flights or other things. But it can also be transferred out, because it is proof of useful work; it is something that people have done real work to deserve, it’s not just a vehicle for moving numbers around. Those people should be able to say, “Here’s an invoice. This is what I’ve done for the network and I got USD 13.19 worth of value from that.”

As users start having ongoing relationships with service providers, it makes sense for them to switch from pay-as-you-go and micro-transactions to subscription. It’s worth USD 5 a month for them to be a charter member of this network. That just means that the deposit, which goes into the reward pool, is ongoing. The user automatically puts in USD 5 to repeat the payment to the retailer, either through a credit card transaction or through an allowance to a smart contract. Ultimately, that subscription is what we’re trying to do. But the concept of a prepaid card helps us understand the basic operating principle of what the Cardstack Ecosystem is. The Subscription Card is just another type of card that automates certain processes, so you don’t have to do it every month and you don’t have to top it off, for example.

Payment cards & the UI / Card SDK (min 36:21)

You can even prepay this stuff. The idea is that all these things are “value in” — whether it’s gifted or earned or purchased by the different participants in our network. With our UI, you just double-click on a card and you see what’s going on; it’s almost like opening up a wallet on your smartphone — very easy to do.

The Card SDK is our front-end technology and the way we create the schema, the model, and the templates for these things. We always intended for these kinds of identity, payment, and membership cards to be an integral part of how we unlock the value of this software and services network. After all, you can make Content Cards, Data Cards, and Asset Cards. But if people are just using your app for free and you have to find a way to bill them for it (maybe charge them a transaction fee, hold their wallet, or put ads on them), then it’s hard to make the Web a real ecosystem; because the websites you’re using are not really serving you, they’re serving the advertisers. By having Reward Cards, Subscription Cards, and Prepaid Cards — at the core of which is the same SDK — we can find a way to say, “You’ve earned USD 13.19, which you can use to pay for a subscription, which costs USD 5 a month. And by the way, you still have a USD 64.30 balance, which you can use as spendable balance to bill the network.”

Deposits & withdrawals (min 37:48)

This is a six-sided thing centering around the reward pool, the locked reserve (where non-CARD tokens are locked to back the value of the services, being contributed to the reward pool through this automated balancing mechanism we’re doing on-chain), and the rendered services (the billable usage). Between the billable usage and the deposits (which the users can make themselves, or they can have retailers make them on their behalf) are the purchases (the actual new value coming into the network), the market rates (telling everybody what the deposits and earnings are worth), and eventually, the withdrawals (you could withdraw directly to a wallet or through the Card SDK and the integration with the Cardstack Hub; you could also use financial intermediaries, whether that’s traditional or crypto ones, which provide services where things get deposited directly to your bank account, Venmo account, or even Libra Coin, if that’s what you want to do). But the idea here is that the interaction with the protocol is basically just like a cloud subscription. Everything’s happening in the background, deducting against your balance, until you say, “I want to take the money out and make a deposit,” to interact with what we know as the banking or crypto or financial service organizations.

Product grid of providers, developers, users (min 39:49)

That’s how the Card SDK (the UI and the logic), the CARD Protocol, and the Cardstack Hub are doing a lot of the calculation and analysis — serving as the basic runtime for Tally, for retailers, and for service providers (who are providing all kinds of services, from database to courier services). That’s been our basic technical framework. Hopefully, the CARD Protocol — which sits in the middle, allowing users to use multiple types of services — will help coordinate this multi-currency payment and billing network across multiple providers.

We’ve been working very hard to not only build the protocol aspects of it, but also think about how this would actually end up being used. We have this idea of a product grid. It’s not really a product line. Other product lines do this for businesses, that for end-users, and this for developers. But in our network, they all overlap. The service providers want to be staking, billing, and getting a reward, and know that a third party (Tally) is telling us how much it is all worth. The developers build on the Card SDK and the hub, so they can also get a portion of the reward. Therefore, the reward is where they overlap.

Beta Tally (min 40:36) and Beta Folio (min 44:54)

Tally is doing a lot of the work; there are a lot of management levers — you have to stake and withdraw and create relationships, etc. Folio is less low-level; it’s more like what the user would see. A folio will be similar to the iOS wallet app. You can say, “this is my mileage card, this is my credit card, this is my prepaid card, this is my Apple card,” and we have a similar concept. Tally is for the provider mostly; it’s more low-level, more of an accounting system. Folio is more like, “How much money do I have? How much can I spend? What membership do I see?”

Tally and Folio are works in progress, and we hope to launch the beta very soon. But let’s take a look at some of the work that we’re doing on the template and how it looks.

Because of the way the Card SDK works, when we’re building a template, we’re also building an API; so, the same thing that powers the user — the same logic, the same computation — also serves data to the oracle, so that on-chain data gets the same approach.

In Tally, we have two concepts: One concept is this prepaid card, because we need to mark the card — the value of the underlying asset — to the market. The other one is the service provider — someone who is billing for and accumulating usage across different user bases, charging different users who have different prepaid cards. They will have a page that summarizes what they are doing.

In this example, the prepaid card is funded using the Aragon token (ANT). It could be funded using any other token, but in this case, we are using an ERC20 token as a deposit. The available balance has to be some continuous calculation of this stuff, so we created something called SSC ID, which is the account number (a hash of a bunch of stuff), and a subscriber address (who holds this prepaid card?). The usage is accumulated over time, showing how you have used the balance that you have deposited and staked for various types of service. The active service providers show how many service providers you are using. One could be hosting your photos, another one could be dealing with your accounting system, and a third one could be paying gas fees for you. Because of the way Cardstack works, one card can tap into 10 different services and different cards can tap into different crypto networks, so the diversity of this pie chart may change. Finally, you can use this to subscribe to a new service provider.

If you take a look at what the providers are doing for you, you see that you’re using Card.Space, which is hosting a website for you, so you can have an on-ramp. Then, there’s Hubs’R’US. They provide Cardstack Hub service and all the things that can be included in plugins — for which you have been billed USD 11.23 thus far. Then, you can go see the provider details and you can say, “I don’t want to do subscription with you. I want to revoke your ability to bill my account, because you’re overbilling me.” That’s how the consumers / the users / the customers can manage the relationships with the (currently three) active service providers who can bill them.

From the service provider’s point of view: These are all the service providers who are listed or who have staked CARD tokens. Their stake determines the limit of how much they can bill. And now, they can go inverse and pivot the other way, data-wise. In this example, Card.Space has 23 subscribers and is billing 15 bucks per month on average. As much as cloud services are growing, this could be a big thing. And that’s the idea here: The service providers manage the customer relationships from their angle and Tally is the neutral, administrative accounting Web dashboard that makes it happen.

So that’s Tally. The capability and UI of Tally will be launching soon. And this is actually acting as the oracle to the smart contracts, so that the data that users see in a Tally node is the same data that informs activity on-chain.

Folio is a lot simpler than Tally. We want to say, “You have a prepaid card, you have a membership card, and this is the current balance.” We don’t need to get into a lot of detail. That’s it: You have some assets in Ether and CARD. And you could have a MetaMask wallet, for example; in the future, we will also support other types of wallets, whether that’s Trezor or some of the custodial or non-custodial apps that use it. And we just report to you what the USD value (or whatever value that you’re shown) is, using the mark-to-market and the market oracle.

Tally is something that’s new, while we shipped an alpha of Card Folio already, to show the basic capability, and we open-sourced the Card Folio codebase in January; it’s actually powering both Tally, which is more administrative and more complicated, and the new Card Folio. So, these are the two things that will be launching soon! If you have a MetaMask account, you can start using Folio. And to use Tally, you can actually stake to become a service provider and start experimenting. Tally will initially launch on testnet, because there are a token pool and stake pools involved in it, so we want to make sure that those are working correctly. Card Folio is basically a read-only app, like an explorer or wallet. For now, it uses MetaMask for transactions. So that’s going to go on testnet, and you can use that and play with it soon.

Smart contract / GitHub (min 46:19)

This is an interesting description of the underlying smart contracts. We call it the “smart contracts necessary for the CARD Protocol.” Most of the heavy lifting is actually done in the Cardstack Hub in off-chain land. So there are some parts of the protocol that need to happen: There are contracts and oracles and integration and creating various-level pools, whether it is the reward pool or stake pool or reserve pool.

The basic idea here is that we are trying to keep the service area of smart contracts as small as possible. Smart contracts are high-capability, because we’re building this mechanism in Ethereum — for two reasons: One is that the tools are mature and we’re using the OpenZeppelin library, so it’s upgradable, we can improve it over time. But more importantly, there’s a lot of representation of assets — stable coins like Dai or USDC or TrueUSD. There is capability for you to participate in the money market; you can take loans against it, if that’s what you want to do. And with this idea of creating a deposit, it makes sense for us to leverage all these other decentralized finance or DeFi innovations and essentially provide a pool — a smart contract that allows those things to be converted and staked, to create this much more dynamic and user-focused billing mechanism.

So, we have the reward pool, the reserve pool, the oracle, and then the active service registry, showing which customers and service providers have a relationship, and that can be cancelled from both sides.

The reserve pool and the reward pool are essentially a smart contract that locks these things together and provides capability. The reserve pool is mostly about how many other tokens you’re putting in; it’s kind of a multi-sig wallet. The reward pool is denominated in CARD tokens; and any reserve that is deposited will create the correspondent reward pool. The withdrawal and the payout come from the reward pool. Then, with integration (we hope to integrate with a decentralized exchange like Uniswap and maybe even Kyber), you can automatically convert it back to what you have. And the reserve pool would be there to say, “this is the total network value that is in the system.” So, the CARD Protocol has these relatively small pieces of modular code that support all the things that are going on in the smart contract, while the smart contract supports the overall protocol.

1. Card Folio is the first end user-facing launch pad for new types of cards that tap into and wrap the power of decentralized networks in a composable way. We’re using it to show what you can do with the Cardstack UI, the Card SDK. Right now, we’re doing prepaid cards, because there are a lot of moving pieces; and with prepaid cards, you basically get all the Tally and the usage billing things right. Once you have that, you can use the prepaid card to pay for registering on Ethereum Name Service. You can buy crypto collectables to a degree that make sense, if they are unclutched (if they’re clutched, you can only pay the fees on them). We will be integrating with other DeFis (decentralized finance), DAOs (decentralized organizations), and DID (decentralized identity), taking a look at what’s going on both within the Ethereum space and beyond, like the Decentralized Identity Foundation that Microsoft is sponsoring. And we reflect that stuff in a card way. If it’s a card and it’s built on the Card SDK, Card Folio is like the standard UI for you to visualize all this stuff. The most important thing about Card Folio — or the Cardstack UI that underlines it — is that you can wrap the power and then chain this together: “Please take this and do that with it, and when it’s done, go and send it to this person.” This kind of orchestration allows us to use these basic units as building blocks almost like songs in a playlist; and then, your playlist could decide how to orchestrate everything together. So, Card Folio is for end users.

2. Tally is the administrative layer to coordinate the four-sided economy. We want to do as much computation as possible using the functional reactive properties of the Cardstack Hub; so, when you update one cell (almost like in Excel), all the other formulas propagate through the sheets. That’s technically possible in Ethereum, but each time, you have the wait for block time and you have to pay gas, which is not always possible. By doing this off-chain computation in the Cardstack Hub, we can keep all these numbers up-to-date. They’re indexed. And the process is accelerated through databases, Postgres, and all these kinds of JavaScript capability. In the future, we’re going to be tapping into machine learning algorithms, so that the calculation of risk can be done by looking at all this data that is available in the Tally database. Then, we can say, “I believe it’s USD 40 worth of risk,” and that can influence users.

What we want to do is interact with the chain with a technique that’s proven. A lot of people are inventing new stuff we keep track of (we just hosted a workshop for state channels). We’re looking at different types of capability. Right now, oracles are the easiest way to do it. But this is not centralized; Tally is running on top of Cardstack, and the Cardstack Hub can run anywhere. So, you can have 50 different Tally nodes in different countries running the same algorithm, performing the same analysis on the same on-chain data. Then, you can choose which one will be your payment or withdrawal authorizer, and they will have some risk. If they tell you they are withdrawing USD 40, but you actually do not have USD 40 worth of value, a Tally worker essentially has to slash the stake as well. Tally workers will become analytic miners — providing analysis service using the Cardstack Hub’s functional reactive properties. They get chosen either dynamically, randomly, or through a long-term relationship, to provide the service for the different participants of the network, acting as the accountant of this decentralized economy.

3. We are going to continuously evolve what’s on-chain and what’s off-chain into what we call the “on-chain / off-chain mix” to balance all the qualities that matter in real Web apps: ease, speed, cost, trust model, security, etc.

A lot of projects, especially in the Ethereum space, want to do as much as possible on-chain, because that makes sense when you’re dealing with decentralized finance, where you want to have a very accurate on-chain measurement of the underlying assets. When you get into payment systems and membership systems, it’s possible for us to use off-chain techniques and serious cryptographical primitives like SSL and HTTPS (it is not on-chain, but it is cryptographic), to make sure that things are not drifting too far away from what’s been staked on-chain. The key here is that real Web apps — ones that serve millions of users every day — need to be easy to use and fast in terms of the UI. They have to be cost-effective, they need to have a decent trust model (what we have right now, with the centralized digital super powers, leaves a little bit to be desired), and obviously, they need to be secure — not in terms of theoretical security, but in terms of the risk of people losing their funds and stuff like that.

This is pretty high-bar. Blockchain and smart contracts have a lot to offer if we inject blockchain in the right part of the ease, speed, cost, trust model, and security qualities. Currently, our spend supply (the accounting ledger for usage) is done using the Cardstack Hub. It would make sense for that to be done in a side chain or plasma chain, so that the different service providers know how much has already been billed. They share that information in a more efficient way than going to a main net — which is good for large amounts, but not for 20 cents, when your gas fee of recording that small transaction costs 20 cents on a bad day.

What’s nice about the CARD Protocol is that we could swap out the implementation to use a plasma chain, if one became available, without changing much of the rest of the protocol. So, we’re going to continue looking at this, analyzing it. Think of Cardstack as the payoff. Cardstack has all these working systems and UI. And we can say, “that’s ready to go to plasma chain, so let’s switch over to that”; and suddenly, everybody is like, “hey, we’re using plasma chain underneath.” It’s almost like saying, “we’ve switched from the Amazon Web Server to Azure or Google Cloud.” The users who are booking a card don’t really care; they wouldn’t care whether we’re using the plasma / side chain underneath. But between ease, speed, cost, trust model, and security, we will improve by switching to these kinds of protocol when they’re ready to go.

Another aspect of it is that we really want to improve the end user experience. We like MetaMask in terms of giving people an understanding of what it means to be a direct participant in this ecosystem (by using MetaMask as their wallet); but for most use cases, for people who are buying a prepaid card, it doesn’t make sense to ask them to use MetaMask to hold their balance. That’s why we want to have a hosted (yet non-custodial) wallet, which balances security and ease and trust. There’s a lot of really nice research on threshold multi-sig and new products coming to the market. We’re keeping an eye on that space and seeing how we can turn that into an abstracted scheme. The goal is that, with Card Key, you can sign your transaction in three different ways — the traditional MetaMask way, through a Trezor wallet, and maybe using a future type of threshold multi-sig, where you may just use an iPhone plus a hosted service.

The goal of Cardstack has always been about bringing the decentralized protocol to the surface, so people can understand the protocol and the composability of the Cardstack UI. Signature, balances, prepaid cards, and relationships with service providers are just different aspects of these units of relationship, and those can all be represented using cards, both on the front-end and as a way to orchestrate the back-end.

For us, Cardstack is at the center of this network, and we see the CARD Protocol as the economic layer to make it all worthwhile. People do not just participate in it because they believe in open source or decentralization — but because this is the best way for them to access the greatest number of customers, the greatest network of collaborators and other businesses, so they can provide seamless service to mutual customers. And hopefully, the CARD logo will become as ubiquitous as a Visa and Mastercard logo, so that everyone says, “They’re using Cardstack! They accept the CARD Protocol, so they can serve me, and I’m going to get everything I need for a reasonable fee.” This will allow us to build the Web 3.0 that not only has the qualities of the connected Web, but that decentralizes the value part, that decentralizes what is now locked into app stores, including advertising support effects.

We will release the source code of our smart contract; but more importantly, we will let people play with it on Rinkeby testnet, as we want to be able to get community feedback on how this is working. Then, the payment mechanism will evolve. As we add more services, more cards, and more community features, it will become more obvious why this prepaid card becomes the pass for all of the things you can do on the decentralized Web.

Learn More

Star Cardstack on GitHub and join our Discord channel or our Telegram group and announcement channel to get all our latest updates.