MyZubster Marketplace: From a Simple Request Button to Verified Wallet-Signed Intent

Leader ●2 ●24 ●155
calendar_today • schedule6 min read

MyZubster Marketplace: From a Simple Request Button to Verified Wallet-Signed Intent

We recently reached a new milestone in the MyZubster Marketplace.

What started as a simple:

User → Request listing → Create order

has evolved into a wallet-verified, cryptographically signed Marketplace request flow.

The important part is that we did not turn every Marketplace action into a blockchain transaction.

Instead, we separated four concepts that are often mixed together:

Wallet ownership
≠
Signed intent
≠
Payment
≠
Blockchain evidence

Here is what we implemented, how it works, what we tested, and what still needs to be built.

The original problem

Previously, the Marketplace frontend could create a request directly through the API.

Conceptually:

POST /api/marketplace/orders

That works for a traditional Marketplace, but we wanted stronger evidence around user intent.

We wanted the system to know:

  • which authenticated account initiated the request;
  • which EVM wallet the user actually controls;
  • what exactly the user agreed to request;
  • what the listing conditions were at signing time;
  • whether the authorization had already been consumed;
  • whether the listing changed before the request reached the server.

At the same time, creating a request should not require gas.

A user asking a seller about a product or service should not have to broadcast an Ethereum transaction.

So we designed the request as an off-chain signed action.

Step 1: Verify wallet ownership

The first component is EVM wallet linking.

The browser requests the user's account through an EIP-1193 provider.

eth_requestAccounts

But obtaining an address does not prove ownership.

So MyZubster creates a challenge.

POST /api/wallet/challenge

The wallet signs it with:

personal_sign

The signature is then submitted to:

POST /api/wallet/verify

The backend verifies the signer.

Only after that do we consider the wallet verified for that MyZubster account.

This gives us our first important rule:

CONNECTED != VERIFIED

Step 2: Protect challenges against replay

A valid signature must not become a reusable authorization token.

Wallet and Marketplace challenges therefore have nonces, expiration and consumption state.

Once consumed, a challenge cannot simply be replayed to authorize another operation.

The backend distinguishes errors such as expired, already-used, invalid and non-consumable challenges.

Replay protection became especially important once the same architecture started authorizing real Marketplace state changes.

Step 3: Create a Marketplace-specific challenge

A verified wallet still does not automatically authorize a Marketplace request.

When the user clicks Request, the frontend asks the backend for another challenge:

POST /api/marketplace/orders/challenge

This challenge represents the specific Marketplace action.

The frontend then shows the user what is about to be signed.

Only after confirmation does the wallet receive the personal_sign request.

The signed challenge is finally submitted to:

POST /api/marketplace/orders

If everything verifies correctly, the backend creates:

MarketplaceOrder
status: REQUESTED

Step 4: Sign the economics, not just the listing ID

This was one of the most important improvements.

Imagine this:

User sees:       €10
Challenge made:  €10
Listing changes: €100
User submits old signature

A system that signs only a listing identifier could create ambiguity about what the user actually authorized.

Our V2 Marketplace payload therefore includes an economic snapshot.

Conceptually:

{
  "schema": "MYZUBSTER_MARKETPLACE_REQUEST_V2",
  "listingSnapshot": {
    "price": 10,
    "currency": "EUR",
    "exchangeMode": "payment"
  }
}

When the signed request reaches the backend, the server compares the signed snapshot with the current listing.

If the economics changed, it returns:

MARKETPLACE_LISTING_CHANGED

No order should be created from the stale authorization.

The user has to review the new conditions and sign again.

Step 5: Make request creation transactional

Replay protection introduced another engineering problem.

Consider:

Challenge consumed
        ↓
Database operation fails
        ↓
No Marketplace order

Now the authorization has been destroyed without producing the operation it authorized.

We therefore made challenge consumption and order creation part of the same database transaction.

Conceptually:

BEGIN

verify challenge
consume challenge
create REQUESTED order

COMMIT

Notifications happen after the core transaction succeeds.

This keeps the authorization lifecycle aligned with the Marketplace state transition.

Step 6: Integrate the browser wallet

The React Marketplace now connects the real Request button to this flow.

The browser sequence is approximately:

User clicks Request
        ↓
Check MyZubster authentication
        ↓
eth_requestAccounts
        ↓
Check wallet verification
        ↓
Verify wallet if necessary
        ↓
Create Marketplace challenge
        ↓
Display signed conditions
        ↓
User confirms
        ↓
personal_sign
        ↓
Submit signature
        ↓
REQUESTED

And here is what deliberately does not appear:

eth_sendTransaction
eth_sendRawTransaction

A Marketplace request does not require an on-chain transaction.

Signature UX matters

Wallet prompts can easily confuse users.

Someone sees a crypto wallet popup and may reasonably assume:

Am I paying something?

So before the Marketplace signature, the UI explicitly explains:

This signature creates a Marketplace request.

It does not authorize a payment.
It does not send a blockchain transaction.
No gas.

This is not just UX copy.

It reflects the architecture.

SIGNED != PAID
REQUESTED != ACCEPTED

Testing the complete flow

We added backend coverage across six wallet/Marketplace suites.

Current checkpoint:

Test Suites: 6 passed, 6 total
Tests:       25 passed, 25 total

The tests cover areas including:

  • wallet signature verification;
  • challenge consumption;
  • replay protection;
  • Marketplace request verification;
  • transactional request creation;
  • listing economic changes;
  • wrong-wallet signatures;
  • end-to-end signed Marketplace requests;
  • the existing Marketplace lifecycle using the new signed request path.

We also added browser-side tests for the wallet client.

Those cover:

verified wallet → signed request

new wallet
→ ownership challenge
→ verification
→ Marketplace signature

user rejects personal_sign → code 4001

missing EIP-1193 provider → fail safely

listing economics changed → propagate 409

The frontend production build also passes.

Where blockchain fits

MyZubster already has a separate Marketplace evidence architecture capable of anchoring evidence on Base.

But that is a different layer.

The design is closer to:

USER INTENT

MyZubster account
        ↓
Verified EVM wallet
        ↓
Off-chain signature
        ↓
Marketplace REQUESTED


MARKETPLACE LIFECYCLE

REQUESTED
↓
ACCEPTED
↓
...
↓
COMPLETED


EVIDENCE

Completed Marketplace event
        ↓
Evidence generation
        ↓
Hash
        ↓
Optional blockchain anchor

This separation matters.

Putting a hash on a blockchain can provide evidence about a digital digest.

It does not automatically prove a claim about the physical world.

So another rule remains:

CONFIRMED_ON_CHAIN
!=
PHYSICAL_EVENT_VERIFIED

Blockchain evidence, Marketplace evidence and physical evidence are different things.

What is implemented now?

At the current milestone:

EVM wallet linking                  IMPLEMENTED
Wallet ownership verification       IMPLEMENTED
Challenge expiration                IMPLEMENTED
Replay protection                   IMPLEMENTED
Signed Marketplace requests         IMPLEMENTED
V2 economic snapshot                IMPLEMENTED
Transactional request creation      IMPLEMENTED
React wallet request integration    IMPLEMENTED
Browser signature review            IMPLEMENTED

Backend checkpoint                  25/25 PASS
React production build              PASS

The implementation is now available in the MyZubster repository through the feat/wallet-marketplace-mvp branch and PR #1207.

What is still missing?

This milestone is not the same as saying the entire Marketplace payment architecture is production-ready.

Several pieces remain.

Public deployment verification

The branch still needs to complete the normal review, merge and deployment process.

After deployment we need a real public HTTPS end-to-end wallet test.

Stronger signature context

A future hardening step is SIWE-style domain and URI binding.

This would make the context of the signature even more explicit and reduce ambiguity across domains.

Production abuse controls

Wallet challenge endpoints still need production-oriented rate limiting and abuse protection.

Additional idempotency protection

Replay protection already exists, but database-level uniqueness around critical challenge/evidence identifiers can add another defensive layer.

Payment infrastructure

Most importantly:

wallet signing is not our payment implementation.

Payments remain a separate future phase.

The Marketplace direction is still free-first:

Create MyZubster account
        ↓
SELLER_FREE
        ↓
Publish listings
        ↓
Receive real requests
        ↓
Build Marketplace activity
        ↓
Activate financial onboarding
only when payment is actually needed

Connecting a wallet must not silently create a subscription or payment authorization.

Zorgax Listing Assistant

Another planned layer is the integration of Zorgax into listing creation.

Instead of presenting sellers with only a traditional form, Zorgax can help turn an idea into structured listing data.

Conceptually:

"I repair computers around Cesena"
        ↓
Zorgax
        ↓
Title
Category
Description
Location
Availability
Price / FREE / BARTER
Characteristics
        ↓
Editable preview
        ↓
Seller confirmation
        ↓
Published listing

But the evidence rule remains:

ZORGAX_DRAFT
!=
SELLER_CONFIRMED
!=
PUBLISHED

AI assistance should structure information, not silently convert generated text into verified facts.

The bigger architecture

What interests us most about this work is not simply adding a crypto wallet.

It is building explicit boundaries between different kinds of evidence.

ACCOUNT
   ↓
WALLET OWNERSHIP
   ↓
SIGNED INTENT
   ↓
MARKETPLACE STATE
   ↓
PAYMENT STATE
   ↓
DIGITAL EVIDENCE
   ↓
OPTIONAL BLOCKCHAIN ANCHOR
   ↓
REAL-WORLD EVIDENCE

Each layer answers a different question.

A wallet signature can prove control of a key and authorization of a specific message.

A database transaction can preserve application consistency.

A payment processor can provide financial settlement evidence.

A blockchain can provide durable anchoring of a digital digest.

And none of those, by themselves, prove that a real-world event actually happened.

Keeping those boundaries explicit is becoming one of the core architectural principles behind MyZubster.

Current milestone

Nine commits now separate the original Marketplace request flow from the new signed-wallet architecture.

The result is not:

"We put the Marketplace on blockchain."

It is closer to:

We are building a Marketplace where identity, intent, payment and evidence can be connected without pretending they are the same thing.

The next challenge is moving this from a tested implementation to a publicly deployed flow, then connecting it with the free-first Seller experience, payments and Zorgax-assisted listing creation.

That is the next MyZubster Marketplace milestone.

🔥 Join developers growing publicly
Share your knowledge, build in public, and grow your developer presence with a global community.

More Posts

The Sovereign Vault — A Comprehensive Guide to Protocol-Driven AI

Ken W. Algerverified - Jun 4

AAIF Hits 10 Projects. Its CTO on What to Adopt Now and the Security Gaps Left Open

Tom Smithverified - Oct 23

I Wrote a Script to Fix Audible's Unreadable PDF Filenames

snapsynapseverified - Apr 20

Cisco's Amy Chang: A Model's "Passport" Doesn't Tell You Where It Actually Came From

Tom Smithverified - Aug 27

Python for commerce students, from a former bio kid

rahuldk1105 - Oct 30
chevron_left
4.4k Points • 181 Badges
Rimini
112Posts
17Comments
33Connections

Related Jobs

View all jobs →

Commenters (This Week)

3 comments
1 comment

Contribute meaningful comments to climb the leaderboard and earn badges!