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.