Raxel

What Raxel does, what goes on-chain, and how people and agents use it.

Overview

Raxel is a market for knowledge on Solana. A contributor writes a memory (a markdown document such as a runbook, research summary or prompt spec), registers it as a Metaplex Core asset they own, and sets a price in USDC. Buyers, human or AI agent, pay that price directly to the contributor's wallet and get permanent access.

  • No token. Raxel has no token. Prices and payments are USDC.
  • No platform fee. 100% of each payment goes to the contributor.
  • No custody. Raxel never holds funds or keys. You sign everything in your own wallet.

Wallets & sign-in

Raxel discovers wallets through the Solana Wallet Standard, so any compliant wallet appears automatically: Phantom, MetaMask (via its built-in Solana account), Solflare, Backpack and others. On mobile, open Raxel inside your wallet's in-app browser.

After connecting, you sign a one-time message (Sign-In With Solana style) containing a random nonce. The server verifies the ed25519 signature and issues a 7-day session. Signing in is free and sends no transaction.

Contributing

  1. Write. Go to Contribute, fill in the public fields (title, summary, topic, format, license, tags), the private markdown content, and a price. Use 0 for free.
  2. Save draft. The content is encrypted with AES-256-GCM and its SHA-256 hash is computed. Drafts can be edited or deleted.
  3. Register. Your wallet creates a Metaplex Core asset with attributes raxel_id, content_sha256, topic and price_usdc. Raxel reads the asset back from chain and lists the memory only if the owner and hash match.
  4. Earn. Sales appear in your Dashboard with links to each transaction.
Registered content is immutable because the on-chain hash commits to it. To publish a revision, register a new memory and unlist the old one.

Buying access

On a memory page, click Buy access. Your wallet signs a single transaction that:

  • creates the contributor's USDC token account if it doesn't exist yet (idempotent, paid by you),
  • transfers the exact price in USDC with transferChecked to the contributor,
  • adds a memo raxel:<memoryId>.

Raxel then fetches the confirmed transaction from Solana and checks the token program, mint, destination, signer and amount before granting access. Each transaction signature can only be used once.

Agent API

Agents use the same endpoints as the web app. Authentication is a wallet signature, payment is a USDC transfer.

1 · Get a session token

POST https://useraxel.xyz/api/auth/nonce      { "wallet": "<base58 pubkey>" }
→ { "nonce": "...", "message": "..." }

# sign `message` (UTF-8 bytes) with the wallet's ed25519 key
POST https://useraxel.xyz/api/auth/verify     { "nonce": "...", "signature": "<base58>" }
→ { "wallet": "...", "token": "<jwt>" }   # send as Authorization: Bearer <jwt>

2 · Request content, receive 402

GET https://useraxel.xyz/api/memories/{id}/content
Authorization: Bearer <jwt>

HTTP/1.1 402 Payment Required
PAYMENT-REQUIRED: <base64 JSON, same as accepts[0]>
{
  "error": "Payment required",
  "accepts": [{
    "scheme": "exact",
    "network": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
    "asset": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    "amount": "5000000", "decimals": 6,
    "payTo": "<contributor wallet>",
    "payToTokenAccount": "<contributor USDC ATA>",
    "memo": "raxel:{id}",
    "settle": { "method": "POST", "url": "https://useraxel.xyz/api/purchases" }
  }]
}

3 · Pay and settle

import { PublicKey, Transaction, TransactionInstruction, sendAndConfirmTransaction } from "@solana/web3.js";
import { createAssociatedTokenAccountIdempotentInstruction, createTransferCheckedInstruction,
         getAssociatedTokenAddressSync } from "@solana/spl-token";

const req = (await res.json()).accepts[0];
const mint = new PublicKey(req.asset), payTo = new PublicKey(req.payTo);
const from = getAssociatedTokenAddressSync(mint, agent.publicKey);
const to = getAssociatedTokenAddressSync(mint, payTo, true);

const tx = new Transaction().add(
  createAssociatedTokenAccountIdempotentInstruction(agent.publicKey, to, payTo, mint),
  createTransferCheckedInstruction(from, mint, to, agent.publicKey, BigInt(req.amount), req.decimals),
  new TransactionInstruction({ programId: new PublicKey("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"),
                               keys: [], data: Buffer.from(req.memo) }),
);
const signature = await sendAndConfirmTransaction(connection, tx, [agent]);

await fetch(req.settle.url, {
  method: "POST",
  headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
  body: JSON.stringify({ memoryId: id, signature }),
});
// Now GET /content returns 200 { content, contentSha256 }

The transfer must be signed by the same wallet that holds the session. Verify integrity by hashing content with SHA-256 and comparing it to contentSha256 and to the asset's on-chain content_sha256 attribute.

The 402 response follows the shape of the x402 "exact" scheme, but settlement is a direct on-chain transfer verified by Raxel, not a facilitator. Standard x402 client libraries will need the small adapter shown above.

Endpoint reference

MethodPathAuthPurpose
GET/api/memories?q=&topic=&sort=—Search listed memories (sort: new, popular, price_asc, price_desc)
GET/api/memories/{id}optionalPublic details + viewer access flags
GET/api/memories/{id}/contentrequiredContent, or 402 with payment terms
GET/api/memories/{id}/metadata—Metaplex JSON metadata
POST/api/memoriesrequiredCreate an encrypted draft
PATCH/api/memories/{id}ownerEdit draft, or list/unlist
POST/api/memories/{id}/registerownerVerify a Core asset and list
POST/api/purchasesrequiredVerify a USDC payment and grant access
GET/api/merequiredYour memories, purchases and sales
GET/api/stats—Market totals

Architecture

Contributor wallet ──(Metaplex Core create)──▶ Solana: asset { content_sha256, raxel_id, price }
        │                                                     ▲
        └─ draft (AES-256-GCM) ─▶ Raxel API ─(fetchAsset)────┘
                                     │
Buyer / Agent ── GET content ──▶ 402 terms
        └──(USDC transferChecked → contributor ATA)──▶ Solana
        └── POST /purchases {signature} ─▶ Raxel API ─(getParsedTransaction)─▶ verify ─▶ grant access
  • Frontend & API: Next.js, deployed as one app.
  • Database: libSQL (Turso in production). Stores listings, encrypted content and the access ledger.
  • Chain: Metaplex Core program for assets, SPL Token program for USDC. Raxel deploys no custom smart contract.

Security model

  • Raxel never asks for a seed phrase or private key.
  • Sign-in messages contain a single-use nonce that expires in 10 minutes.
  • Sessions are HTTP-only cookies (or Bearer tokens for agents) signed with HS256.
  • Content is encrypted at rest with AES-256-GCM; the key never leaves the server.
  • Payments are verified from chain data: success status, token program, USDC mint, destination ATA, signer and amount. Signatures are single-use.
  • Registration is verified by reading the asset back: owner and content hash must match.

Operators must keep RAXEL_ENCRYPTION_KEY safe; whoever runs the server can decrypt content. This is a trust assumption you should state to your contributors.

Costs & fees

ActionWho paysApprox. cost
Sign in—Free
Register a memoryContributor≈ 0.003 SOL (asset rent + fee)
Buy accessBuyerPrice in USDC + ≈ 0.00002 SOL fee (+ ≈ 0.002 SOL once if the contributor has no USDC account yet)
Platform fee—0%

FAQ

Is there a Raxel token?+

No. None has been launched and none is planned. Any token claiming to be Raxel's is not ours.

Does a receipt prove an AI used my content?+

No. It proves a wallet paid for and was granted access. How a model uses content cannot be proven by a payment.

Does registering prove I own the IP?+

No. It records that your wallet claimed authorship of specific content at a specific time.

Can I change the price after registering?+

Not currently. Register a new memory with the new price and unlist the old one.

What happens if Raxel goes offline?+

Your asset and all payments remain on Solana. Content stored by Raxel would be unavailable until the service returns, so keep your own copy.

Can I get a refund?+

Payments are on-chain transfers to the contributor and are final. Raxel cannot reverse them.