The Artists' Collective — Project deep-dive

Overview

What the project is

The Artists' Collective is an online marketplace for original art in which the artists are the owners. It pairs a conventional fiat storefront for buyers with a native Usernode dApp for artists, both reading from and writing to a single on-chain data layer.

Buyers never touch a wallet or a token. They browse, pay in fiat, and receive a normal web checkout. Artists get something the incumbent platforms do not offer: on-chain membership, governance over the platform's economics, and a verifiable record of every sale. The blockchain is the trust layer underneath a familiar web experience, not a feature the user has to learn.

How it works

The whole pipeline — and what's live right now

A buyer pays in fiat on the website; the blockchain records an immutable receipt of what happened (price, the artist's share, the fee). Artists vote with their own wallets. Here is the entire flow on one diagram:

The Artists' Collective — full on-chain pipeline

Live now

Working today

✅ The gallery, the backend and a self-hosted Usernode node.

✅ Every sale writes a confirmed on-chain receipt — price, the artist's 80%, the 20% fee — that mines canonical on the public chain. See them on our live ledger.

✅ Self-send receipts — each receipt is a single transaction the platform wallet sends to itself, carrying the data in the memo, so the wallet never drains. How it works ↓

Live now

Verifiable on the explorer

✅ Every receipt is confirmed canonical on the public Usernode explorer.

Our ledger page live-verifies each receipt against the explorer as you read it, and every transaction hash links straight to the explorer so you can check it yourself.

Coming next

Not live yet

🟡 The in-app governance vote — the governance wallet that collects votes and self-sends the result is ready; the dApp's real-bridge wiring is the last step.

Architecture

Two surfaces, one chain

The product is split into two front-ends with different audiences and constraints, connected through one shared data layer that is mirrored on Usernode.

Buyer website

A conventional web app

A static single-page app served on Cloudflare Pages, with Functions for dynamic routes, D1 (SQL) for the catalogue and artist profiles, and R2 for artwork and portrait storage.

SEO-indexable, fiat checkout, no wallet. This is what a collector sees.

Artist dApp

A native Usernode app

Runs inside the Usernode mobile app and standalone. Artists authenticate with their own Usernode wallet through the bridge APIs (getNodeAddress, sendTransaction, getTransactions), with the native runtime detected via an async handshake.

Membership, governance and the on-chain ledger live here.

Shared layer

One synced source of truth

Enrolling on the dApp publishes the artist's live profile and gallery to the buyer website. Avatars and galleries stay in sync across both surfaces.

A magic-link bridges a phone-held wallet session to a desktop browser, so an artist can manage the store from either device.

On-chain

What actually runs on Usernode

Every artist-facing action is a real Usernode transaction on the testnet, signed and verifiable. The mechanics:

✓Own-wallet signing

The governance vote is signed by the artist's own Usernode key and approved in the app — no custodial shortcut. Enrolment and sale receipts, by contrast, are written server-side by the platform's app key.

✓On-chain membership

Enrolling as a member-owner is a Usernode transaction. Joining the collective is recorded on the chain, not in a private database alone.

✓Governance that mutates state

A member vote changes the real platform fee (for example 20% to 15%). Each artist signs their vote with their own wallet into the governance wallet, which tallies them and self-sends the decision on-chain — a transaction that moves the live number, not a cosmetic poll.

✓Verifiable receipts

Each enrol, sale and vote is a real Usernode transaction carrying a base64url JSON memo with the full event (work, price, artist share, fee). The chain holds the canonical proof; the readable detail lives in our database, and the two are joined on our live ledger page — each row live-verified against the public explorer.

✓Self-send receipts

Every receipt moves one carrier token, so a wallet paying receipts out to a separate address would slowly drain. The fix is the simplest one: the platform wallet sends the receipt to itself. The one token returns, the chain fee is zero, so the balance is conserved — it can post receipts forever without topping up. Self-sends mine canonically like any other transfer; the receipt data rides in the memo. One wallet, one transaction per sale, no carrier and no clean-up bot.

✓Self-hosted node + app signer

A self-hosted Usernode node plus an app-key signer lets the platform post a receipt for a sale server-side, through the node's wallet RPC, with no manual approval tap. The chain fee is zero; the platform fee is carried as data in the memo.

✓Durable-first writes

Every action is written to the platform database first, then to the chain, and the receipt hash is only published once the explorer confirms it canonical. If a send fails the product stays consistent and reports honestly — it keeps working even when the chain is slow.

For the hackathon demo, the fiat payment rail (card capture) is simulated by a bot so the end-to-end flow can be shown. The on-chain backend — a self-hosted Usernode node plus an app-key signer — is deployed and writing live receipts: every sale is recorded as a confirmed on-chain transaction that mines canonical on the public chain, visible on our ledger page and on the Usernode explorer. Sales settle in fiat off-chain; the chain holds the immutable record of what happened, including the fee as data.

The product vision

Stripe as the source of truth

This is the model we are building toward for the full product. The hard part of any fiat-to-chain system, named honestly: linking an off-chain payment to its on-chain record needs a trusted attestation that the sale really happened. Our answer is to anchor that trust to Stripe — the payment processor everyone already relies on.

In the real product, when a buyer pays by card, Stripe issues a cryptographically signed confirmation that the money changed hands, and that signed proof is what gets written to Usernode. The chain never takes the gallery's word for a sale; it is anchored to Stripe's signed receipt. Every artist can then verify, independently and without trusting us, that a sale was real — for the exact amount, with the exact fee split.

Buyer pays by card

A normal fiat checkout. No wallet, no token.

→

Stripe signs it

Stripe returns a cryptographically signed receipt — the source of truth.

→

Written on-chain

That signed proof is recorded on Usernode as a verifiable receipt.

→

Artist verifies

Anyone can confirm the sale on-chain, trustlessly.

Refunds follow the same logic: the chain can't delete, so a refund is a reversing entry, and fees sit in a holding period before they count — the way Stripe and the marketplaces already work.

This is the trust bridge we are pitching for the full product, put up for discussion. For the hackathon demo the payment is simulated by a bot that buys images, so the whole end-to-end flow can be shown; the real product anchors it to Stripe's signed webhooks. If there's a cleaner attestation mechanism, we'd love to hear it.

Components

What we built

The pieces that make up the project, end to end.

Buyer marketplace — SPA on Cloudflare Pages + Functions, D1 catalogue, R2 media.

Native Usernode dApp — wallet sign-in, studio dashboard, governance, on-chain ledger.

App-key backend signer — an HTTP service (enrol, sale) over the node wallet RPC.

Self-hosted Usernode node — a sidecar node on the testnet that the signer points at.

Magic-link wallet bridge — links a phone-held wallet session to a desktop browser.

Website ⇄ dApp sync — enrolment publishes profile + gallery to the storefront.

Receipt encoder — a self-send transaction + base64url JSON memo for enrol, sale and vote events.

Demo payment bot — simulates the Stripe → on-chain receipt pipeline for the walkthrough.

The artist surface

The operations, on screen

The dApp side of the gallery. Each panel is backed by a Usernode transaction.

Governance vote — signed with the artist's own wallet

Fee-split proposal — the vote that moves the real fee

Sales ledger — each sale verified on-chain

Governance — your stake & the live fee-split vote (20%→15%), cast on your own wallet, recorded on-chain

Studio dashboard — the artist's on-chain home

Buyer website — a normal shop, no wallet needed

The market

Why it matters

$9B+

online art market, per year

40–50%

commission incumbents take per sale

~200K

artists selling originals online (1M+ with any listing)

The structural problem is ownership. Artists depend on marketplaces they do not own and have no say in, and pay 40 to 50 percent for being listed on what is, mechanically, a website. The Artists' Collective inverts that: the marketplace is owned and governed by the artists who fill it.

For Usernode, this is a large population of non-crypto users with a concrete, non-speculative reason to transact on-chain: ownership, fairer economics, and a real vote. They arrive for a better gallery and leave as on-chain users, without having to learn the word "blockchain."

A gallery the artists own.