Decentralizing with Web3: Token Utility

Tokens are used to exchange value between service providers (the operators of physical infrastructure used for compute) and the games that pay for their services. As noted previously, it also provides a mechanism for independent software developers to deploy code into the ecosystem in a way that lets them add new capabilities to game developers while capturing a royalty in exchange for their work. As the services are used on the network, an ecosystem fee is added to payments, which is then removed from circulation and placed into the project treasury.

Protocol Roles

The value exchanges are implemented via smart contracts. Several roles exist within the protocol implementation:

Developer

A developer is the creator of any microservice code. This could be Beamable, who creates off-the-shelf microservices for a range of capabilities, the creator of a game, or a third-party developer who creates microservices for the ecosystem of game developers to use.

Games

Games are where the fun happens. They frequently need to run microservices to provide a live game experience to their players. When they need a microservice, the game initiates a connection to a Router Node, which matches the game to a particular Container based on criteria such as QoS and price requirements.

The Game’s wallet is debited fees for the workload, including:

• A Service Fee set by the Container for executing the workload

• An optional Priority Fee set by the Game to bid higher than the set Service Fee

• An Ecosystem Fee, a small percentage of the (Service Fee + Priority Fee) which is retained by the Foundation to support ongoing development

• A Developer Royalty, which is a % of the (Service Fee + Priority Fee) goes to the developer of the microservice used (which could be 0% in the event of a public domain microservice or something the Game created for themselves).

Container Nodes

Container nodes host the actual gaming workloads. Beamable containers execute flexible microservices, including everything from custom C# game logic to off-the-shelf “games as a service” modules and third-party plugins.

Containers collect a Service Fee (which they set) as well any Priority Fee.

Because many game developers prefer the relative stability of stablecoin payments, USDC will also be permitted as a pricing model in the network (beyond pricing services in the project’s native token). Container Node operators may set their Service Fee in either the native token for the project or price in USDC (for a higher network fee). In either case, the node operator’s wallet will be credited in a native token, which they must hold for a period of time before withdrawal (partly as a form of decreasing circulating supply to reflect network demand, as well as to permit a challenge period during which time anyone on the network could question whether the node delivered the services it claimed).

In addition, Container Nodes can receive rewards for providing high availability, even when they do not process any workloads. This ensures that Container Nodes are kept online and incentivizes the capitalization of physical infrastructure during the build-up phase of the DePIN.

Router Nodes

Routers are API gateways that link games to the containers capable of delivering the appropriate quality of service (QoS) they need, accounting for factors such as latency (relative to the players and game servers favoring high-speed edge nodes where possible), the container nodes quality-of-service history and overall performance.

One of the keys of decentralized infrastructure is ensuring that the games (and consequently, the players of those games) receive the QoS they’re responsible for. Some games, such as real-time MMORPGs, may require ultra-low-latency responses and have the unit economics to support it. Others (e.g., turn-based strategy games) might be able to accept lower latency. In a DePIN network, you can allow game studios to bid a premium when they require enterprise-grade QoS; likewise, game studios could bid at a lower rate for infrastructure when their needs are more modest.

Router Nodes owners will be rewarded network tokens for providing routing services,

Validator Nodes

Validators are a decentralized network of nodes that make sure the network operates with integrity. They do two types of checks:

Proof of Availability: checks the Container Nodes to verify that they’re available to execute workloads (also called “liveliness”). This is used to reward node operators for setting up physical hardware before the demand is delivered to them.

Proof of Service: cryptographic methods have been developed to confirm that workers in a computational network have performed the work they claim. This includes zero-knowledge proof of computation and verifiable compute algorithms. The validator nodes will be responsible for performing this validation, after which tokens are transferred from the Game’s wallet to the other recipients (the Ecosystem treasury for the Ecosystem Fee, the Container Node for the Service Fee and optional Priority Fee, and the Developer wallet for any royalty they are owed).