Use Case Spotlight: A Decentralized Bluffing & Auction Game on Weilchain

Introducing: Escalate built on Weilchain

Overview

Today, we’re highlighting another application built on WeilChain, not as a game for entertainment alone, but as a concrete demonstration of what application design looks like when state, logic, incentives, and user experience are treated as first-class primitives within the execution layer itself.

Escalate explores how hidden information, adversarial decision-making, and economic risk can be modeled in a single, unified system, without external servers, trusted intermediaries, or fragmented application state.

Introduction

On-chain games have shown how blockchain can be used not just for payments, but also for rich, interactive economic experiments. Escalate is one such experiment: a decentralized bluffing and auction game built on Weilchain that turns hidden information, risk, and staking into a coherent on-chain experience.

In Escalate, players buy random cards using their balance, stake those cards behind public claims, and either escalate the stakes or challenge (“check”) the current position. All game state — player inventory, stakes, auctions, balances, and even the web UI hosting — lives inside a Weil smart contract and its built-in webserver infrastructure.

In this article, we will:

• Introduce the core Escalate gameplay
• Map the game rules to the smart contract design
• Walk through key contract functions with code snippets
• Explain the on-chain auction mechanism
• Outline how the webserver hosting and deployment work (mirroring typical Weilchain patterns)

Game Overview: Bluffing, Hidden Information, and On‑Chain Rewards

At a high level, Escalate is a bluffing game wrapped in a simple on-chain economy:

• You register a profile and get access to a balance.
• You spend this balance to buy random cards.
• You start or join “hands” where a claimed rank (like QUEEN) is announced and players secretly stake cards behind that claim.
• Other players can either stake more cards or “check” (challenge) the last stake.
• When a check happens, only the latest stake is revealed to determine whether there was a bluff.
• Rewards depend on whether the last stake was honest or a bluff, and whether previous stakes contained honest or bluff cards.

On top of the bluffing game, Escalate adds an auction module where players can list cards for sale, accept bids, and resolve the sale fully on-chain. The entire system is modeled in Rust with Weilchain primitives, using WeilMap, WeilVec, and a built-in WebServer to host the UI assets from the contract itself.

Core Data Structures and Contract State

The contract’s state is captured in the EscalateContractState struct, which tracks users, hands, offers, and the on-chain webserver:

A few important details:

• users and user_ids track registered players and their order of registration.
• hands and hand_ids track the active and resolved bluffing hands.
• offers and offer_ids track cards listed for auction.
• hand_counter and offer_counter provide simple, sequential IDs for new hands and offers.
• server enables storing and serving frontend assets via the contract’s HTTP interface.

The contract also defines core reward constants:

These per-card values drive the economic incentives: honest cards earn a baseline reward, while bluff cards that survive without being caught earn a slightly higher reward.

Player Lifecycle: Registration, Inventory, and Cards

Before doing anything, a user must register:

• If the user already exists, their bio is updated.
• Otherwise, a new User is created and tracked in users and user_ids.

Inventory (cards) and balance live on the User object (from the user module). Cards are acquired by spending balance:

Game rule mapping:

• “Buy cards: each whole unit of balance gives one random card.”
• The code floors amount and uses it as a count of cards to draw.
• “Card purchases round down to whole units of balance.”
• spend = amount.floor() ensures only whole units count

Inventory management uses a helper to remove staked or auctioned cards:

This is used both when starting a hand, staking, and creating offers, ensuring cards cannot be reused once committed.

Players can also query only their own on-chain cards:

Hands: Starting, Staking, and Masked Views

Starting a Hand

A hand is the central unit of the bluffing game. To start a hand, a user selects a claimed rank and commits one or more cards:

Game rule mapping:

• “Starting a hand: Choose a rank to claim (e.g., QUEEN) and stake one or more cards from your inventory. Staked cards are removed immediately.”
• claimed_card stores the claim, and remove_cards_from_inventory ensures cards leave inventory on stake.

Staking on an Existing Hand

Once a hand exists, other players (or the original creator) can stake additional cards on the same claim:

Game rule mapping:

• “On your turn — Stake: add hidden cards to the same claim to raise the total (your cards leave inventory).”
• The contract appends a Stake with user_id and cards to the hand.[1]

Masked Hand Views

To keep the game about hidden information, the contract never exposes actual staked card faces in queries. Instead, it masks each stake’s cards as JOKERs

Checking, Bluffs, and Rewards

The central moment in Escalate is when a player decides to “check” the last stake, calling a bluff or confirming the claim.

Checking a Hand

Game rule mapping:

• “Challenge (‘check’): stop further staking and force a reveal of the latest stake.”
• “Reveal the last stake only. A bluff exists if any revealed card does not match the claimed rank (JOKER always matches).”
• “Bluff found: the challenger gains points equal to the size of the revealed stake; all earlier stakers gain per-card rewards.”
• “No bluff: the challenger loses points equal to the revealed stake; all stakers gain per-card rewards.”[1]

The is_bluff(&hand) helper encapsulates the reveal logic; it inspects only the latest stake’s cards relative to hand.claimed_card and the special JOKER rule.

Rewarding Stakers

Rewards for stakers are given via reward_stakers:

This dynamic creates an interesting risk profile:

• Honest cards are safe, steady earners.
• Bluff cards pay more but only if nobody successfully checks in time.

Auctions: Card Offers, Bids, and Resolution

Escalate also includes an on-chain auction system where players can sell cards for balance.

Creating an Offer

• “Create an offer by selecting cards to sell; they leave your inventory while listed.”
• The inventory removal happens immediately via remove_cards_from_inventory

Bidding

• “Other players place higher bids using their balance. If outbid, their locked funds are released.”
• Previous bidder’s funds are returned before taking the new bid

Resolving an Offer

• When the seller resolves: with a current bid, highest bidder gets the cards and seller receives the bid; with no bids, cards return to the seller.”
• The resolution logic perfectly mirrors this rule.[1]

A bidder can also withdraw their current bid, leaving the auction open again.

This keeps the auction system flexible and player-friendly.

Webserver Integration and UI Hosting

After you have made the corresponding dapp using weil-wallet-sdk and have created the build folder for it, you are ready to deploy the whole application on chain

Smart Contract Deployment

Deploy Escalate to Weilchain using the Weilliptic CLI:

deploy -f /home/ubuntu/contracts/escalate.wasm -p /home/ubuntu/contracts/escalate.widl

This command:

• Validates the contract interface (escalate.widl) and compiled contract (escalate.wasm)
• Deploys to the Weilchain network

Loading Frontend Assets

After deployment, load the UI assets to make the contract accessible via HTTP:

load_assets -c aaaaaaus6i25dqmq7o2givrzea5k2aafsupaah27bgs5ubvumyc6vn56q4 -d /home/ubuntu/contracts/escalte-assets/escalate-ui/dist

The load_assets command:

• Takes the compiled React/Vite frontend
• Serves it through the Weilchain webserver
• Makes it accessible at the contract’s HTTP endpoint

The url becomes

https://sentinel.unweil.me/aaaaaaqdp7hlwzyhw77krupyyzbiu3jj5ttbwblis5lme256atoyqvjdhu/static_assets/index.html

Resources

• Weil Documentation: https://docs.weilliptic.ai
• WADK (Weil Application Development Kit): https://github.com/weilliptic-public/wadk
• Weil SDK npm Package: https://www.npmjs.com/package/@weilliptic/weil-sdk