Skip to content

Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.

docs(draft-mint): document the background agent identity mint and prove it end to end on devnet

nirholasd4a91a1bf9f3
diff --git a/data/pages.json b/data/pages.json
index 5d13e6379..c1d045dbd 100644
--- a/data/pages.json
+++ b/data/pages.json
@@ -431,6 +431,15 @@
"description": "Index of live demos across the platform: viewers, agents, payments, and experiments.",
"priority": 0.6,
"changefreq": "weekly"
+ },
+ {
+ "path": "/demos/agents",
+ "title": "Agent Interaction Lab",
+ "description": "Fourteen prototypes exploring how a 3D agent physically inhabits a web page: real gravity, page elements as the playground, and the agent reacting to scroll, clicks, and the cursor.",
+ "priority": 0.5,
+ "changefreq": "weekly",
+ "indexable": false,
+ "added": "2026-08-14"
}
]
},
@@ -2730,6 +2739,14 @@
"changefreq": "monthly",
"added": "2026-07-18"
},
+ {
+ "path": "/docs/draft-agent-mint",
+ "title": "Docs · Draft Agent Mint",
+ "description": "Every finished reconstruction is stored durably and minted as a draft on-chain agent identity: the Solana leg, the ERC-8004 leg, the flags that arm each one, and how to prove the whole path on devnet.",
+ "priority": 0.7,
+ "changefreq": "monthly",
+ "added": "2026-08-14"
+ },
{
"path": "/docs/selfie-to-avatar",
"title": "Docs · Selfie to Avatar",
@@ -3783,14 +3800,14 @@
{
"path": "/docs/vaults",
"title": "Docs: USDC agent vaults",
- "description": "A vault lets strangers put real USDC behind one trading agent, on terms the agent's owner publishes up front. The product-level tour (who each surface is for, how vaults sit next to the Arena, the Theater and Swarms) is in trading-arenas.md, under \"Back-an-Agent Vaults\". Read that first.",
+ "description": "A vault lets strangers put real USDC behind one trading agent, on terms the agent's owner publishes up front. The deep reference: every route and who may call it, the share and fee math, the guards in front of a trade, and the public audit ledger.",
"priority": 0.7,
"changefreq": "monthly"
},
{
"path": "/docs/user-wallet",
"title": "Docs: Your master wallet",
- "description": "Every three.ws agent owns a wallet (agent-wallets.md). Separately, every user account can own one custodial wallet of its own: the master wallet. It is the financial hub for the person rather than the bot.",
+ "description": "Every user account can own one custodial wallet: the master wallet, the financial hub for the person rather than the bot. Provision it, read balances, send SOL or any SPL token, fund an agent, and read its on-chain history, with the spend safeguards on each route.",
"priority": 0.7,
"changefreq": "monthly"
},
@@ -3832,7 +3849,7 @@
{
"path": "/docs/press-kit",
"title": "Docs: Press kit",
- "description": "Everything a journalist, analyst, conference organiser, or partner needs to write about three.ws: the marks, the announcement graphics, approved boilerplate at three lengths, the fast facts, and the rules that govern all of it.",
+ "description": "Everything a journalist, analyst, conference organiser, or partner needs to write about three.ws: the marks, the announcement graphics, approved boilerplate at four lengths, the fast facts, and the rules that govern all of it.",
"priority": 0.7,
"changefreq": "monthly"
},
diff --git a/docs/draft-agent-mint.md b/docs/draft-agent-mint.md
new file mode 100644
index 000000000..76df8925c
--- /dev/null
+++ b/docs/draft-agent-mint.md
@@ -0,0 +1,186 @@
+# Draft agent mint
+
+Every avatar that finishes reconstruction gets two things it did not have
+before: a permanent copy in durable object storage, and a **draft on-chain
+identity**. The identity is minted for you, in the background, with no wallet
+prompt, no fee, and no step to remember. By the time the avatar appears in your
+library it already exists as an asset on a public chain, owned by the agent's
+own wallet.
+
+"Draft" is the operative word. The identity is real and readable by anyone, but
+it is marked inactive: it says *this agent exists and this is its avatar*, not
+*this agent is live and taking work*. Activating it (going live, taking
+payments, appearing in the marketplace) is a separate, deliberate step.
+
+- **Orchestration:** [`api/_lib/draft-mint.js`](../api/_lib/draft-mint.js)
+- **Caller:** [`api/_lib/reconstruct-finalize.js`](../api/_lib/reconstruct-finalize.js), the shared tail of the selfie and prompt to 3D pipeline
+- **Solana mint machinery:** [`api/_lib/onchain-deploy.js`](../api/_lib/onchain-deploy.js) (shared with the batch deployer, so a draft mint is shaped exactly like any other platform mint)
+- **Proof script:** [`scripts/draft-mint-devnet-e2e.mjs`](../scripts/draft-mint-devnet-e2e.mjs)
+
+## Where it fires
+
+`materializeReconstructAvatar()` is the one place a reconstruction becomes a
+durable avatar, and every terminal path in the pipeline funnels through it
+(rigged as-is, rigged after an auto-rig chain, and the unrigged fallback). In
+order, it:
+
+1. writes the GLB to the object store with `putObject()`;
+2. creates the `avatars` row;
+3. marks the regen job `done`;
+4. dispatches the `avatar.created` webhook;
+5. registers the result in the Forge store;
+6. **mints the draft agent identity.**
+
+Steps 4 through 6 are best-effort by contract. The avatar is already delivered
+and visible at step 2, so a webhook, store, or chain hiccup logs a warning and
+the job still succeeds. A draft mint failure never costs a user their avatar.
+
+## The Solana leg (Metaplex Core)
+
+Solana leads. The draft identity is a **Metaplex Core asset** minted into the
+three.ws Agents collection, through the same `deployAgentOnce()` the batch
+deployer uses. That means a draft mint carries everything a normal platform
+mint carries: collection membership, the brand attribute set, the royalty
+plugin, and enrolment in the Metaplex Agent Registry (an Agent Identity PDA).
+
+Ownership resolves in this order:
+
+1. the agent's existing Solana wallet, if it has one;
+2. a freshly generated custodial wallet, when `JWT_SECRET` is configured so the
+ secret can be encrypted at rest and recovered later;
+3. the collection authority, holding the asset in custody until the user claims
+ it.
+
+The owner never signs the mint, so it needs no SOL of its own.
+
+### Networks, and the one flag that arms mainnet
+
+| `DRAFT_AGENT_MINT_NETWORK` | Behavior |
+| --- | --- |
+| unset or `devnet` (default) | Mints on Solana **devnet**. Free, automated, and the proof path. Results are written under `agent_identities.meta.devnet` so they can never be mistaken for, or block, a mainnet mint. |
+| `mainnet` | Mints on Solana mainnet-beta. **This is the only switch that arms real spend.** |
+| `off`, `disabled`, `0` | The Solana leg is skipped entirely. |
+
+Mainnet is never implicit. It requires the operator to set
+`DRAFT_AGENT_MINT_NETWORK=mainnet` **and** fund
+`SOLANA_AGENT_COLLECTION_AUTHORITY_KEY` (or `LAUNCH_FUNDER_SECRET`) on mainnet.
+With no authority secret configured, the leg reports `skipped` and does
+nothing, so a deployment without mint credentials behaves exactly as it did
+before this feature existed.
+
+Budget roughly 0.004 SOL per mint (Core asset rent plus fee), 0.005 SOL once
+for the collection account on a network's first run, and 0.003 SOL for the
+Agent Registry enrolment.
+
+### What lands in the database
+
+| Location | Contents |
+| --- | --- |
+| `agent_identities.meta.devnet` | `sol_mint_address`, `collection`, and the full `onchain` block (CAIP-2 chain id, asset, metadata URI, owner, custody flag, tx signature) |
+| `agent_identities.meta` (mainnet only) | the canonical `sol_mint_address` / `chain_type` / `network` fields every read path keys on, plus the same `onchain` block |
+| `agent_actions` | a `solana.deploy` row for the audit trail |
+| `avatars.source_meta.draft_mint` | the outcome stamp: job id, per-leg status, asset, signature, and timestamp |
+
+The mint is idempotent. An agent that already carries an identity on the target
+network short-circuits to `already` without touching the chain.
+
+## The EVM leg (ERC-8004)
+
+The EVM leg registers the agent's card URI in the canonical ERC-8004 Identity
+Registry. It is off unless explicitly enabled, and it never blocks or delays
+the Solana leg.
+
+| Variable | Default | Meaning |
+| --- | --- | --- |
+| `DRAFT_AGENT_MINT_EVM_ENABLED` | off | `1` / `true` / `yes` / `on` arms the leg |
+| `DRAFT_AGENT_MINT_EVM_CHAIN_ID` | `84532` (Base Sepolia) | any chain in [`api/_lib/erc8004-chains.js`](../api/_lib/erc8004-chains.js) |
+| `EVM_TREASURY_PRIVATE_KEY` | unset | gas source; without it the leg stops at a dry run |
+
+The agent registers itself: the call is signed by the agent's own custodial EVM
+wallet, and the treasury only tops that wallet up to a small gas floor
+(0.00025 native) when it is short. The card the registry URI points at is the
+three.ws Agent Card v1 shape with `active: false`, pinned to IPFS when a
+provider is configured and to the object store otherwise.
+
+**Without a treasury key the leg is a full dry run**, not a stub: it builds the
+real `register(string)` calldata and asks the live chain for a gas estimate,
+then returns `status: 'dry_run'` with the calldata, the registry address, the
+card URI, and the estimate. Nothing is broadcast. That makes the wiring
+provable on a deployment that has no funded EVM wallet at all.
+
+## Proving it end to end
+
+[`scripts/draft-mint-devnet-e2e.mjs`](../scripts/draft-mint-devnet-e2e.mjs)
+runs the real orchestration against real infrastructure: it writes real GLB
+bytes to the object store, creates the avatar row, calls
+`mintDraftAgentIdentity()` with its real dependency set, reads the minted asset
+back **from the chain** with `fetchAsset()`, checks collection membership and
+that the metadata URI resolves, re-reads the database for the durable stamps,
+and exercises the ERC-8004 leg against the live testnet RPC.
+
+It is devnet-only by construction: it refuses to start if
+`DRAFT_AGENT_MINT_NETWORK=mainnet`, and it pins the network to devnet for its
+own process. Nothing it does spends real funds.
+
+```bash
+DATABASE_URL=postgres://… \
+S3_ENDPOINT=… S3_ACCESS_KEY_ID=… S3_SECRET_ACCESS_KEY=… \
+S3_BUCKET=… S3_PUBLIC_DOMAIN=… \
+SOLANA_AGENT_COLLECTION_AUTHORITY_KEY=<devnet-funded base58 keypair> \
+node scripts/draft-mint-devnet-e2e.mjs
+```
+
+The authority needs about 0.02 devnet SOL to cover the collection account, the
+mint, and the registry enrolment on a first run. Fund it at
+<https://faucet.solana.com>. The script writes an evidence JSON (asset,
+signature, explorer link, storage checksum, chain read-back, EVM calldata) to
+`DRAFT_MINT_E2E_OUT`, defaulting to your temp directory.
+
+### Running it without cloud credentials
+
+A local Postgres and any S3-compatible store are enough. The app's database
+driver speaks Neon's HTTP protocol, so a local Postgres needs a proxy in front
+of it; point the driver at that proxy with
+`DRAFT_MINT_E2E_NEON_HTTP_ENDPOINT`.
+
+```bash
+docker network create draftmint-net
+docker run -d --name draftmint-pg --network draftmint-net \
+ -e POSTGRES_PASSWORD=proof -e POSTGRES_DB=threews postgres:16-alpine
+docker run -d --name draftmint-neon --network draftmint-net -p 4455:4444 \
+ -e PG_CONNECTION_STRING=postgres://postgres:proof@draftmint-pg:5432/threews \
+ ghcr.io/timowilhelm/local-neon-http-proxy:main
+docker run -d --name draftmint-minio --network draftmint-net -p 9100:9000 \
+ -e MINIO_ROOT_USER=draftmint -e MINIO_ROOT_PASSWORD=draftmintsecret \
+ -e MINIO_DOMAIN=localhost quay.io/minio/minio:latest server /data
+
+# Apply the repo schema, then every incremental migration, in that order.
+docker cp api/_lib/schema.sql draftmint-pg:/schema.sql
+docker cp api/_lib/migrations draftmint-pg:/migrations
+docker exec draftmint-pg psql -U postgres -d threews -q -f /schema.sql
+docker exec draftmint-pg sh -c \
+ 'cd /migrations && for f in $(ls *.sql | sort); do psql -U postgres -d threews -q -f "$f"; done'
+```
+
+The store is addressed virtual-host style (`<bucket>.localhost`), which is why
+MinIO is started with `MINIO_DOMAIN=localhost`; add
+`127.0.0.1 <bucket>.localhost` to `/etc/hosts` and give the bucket a
+public-read policy so the script's read-back check can fetch the object.
+
+## Failure semantics
+
+| Situation | Result |
+| --- | --- |
+| No authority secret | Solana leg returns `skipped` / `authority_unconfigured`; nothing else changes |
+| Authority underfunded | The mint throws, the caller logs and moves on, the avatar is unaffected |
+| Agent already minted on this network | `already`, with the existing asset address, no chain write |
+| Agent Registry enrolment fails | The mint still stands; the back-fill retries the enrolment later |
+| No EVM treasury key | EVM leg returns `dry_run` with real calldata and a real gas estimate |
+| Database write fails after a mint | The avatar stamp is skipped with a warning; the on-chain asset and the agent meta are already written |
+
+## Related
+
+- [Selfie to Avatar](./selfie-to-avatar.md): the pipeline whose tail calls this
+- [Agent identities](./agent-identities.md): what an agent identity is and how it is generated
+- [Agent tokens](./agent-tokens.md): what happens after a draft identity goes live
+- [The agent index](./agent-index.md): the cross-chain index that surfaces these registrations
diff --git a/scripts/draft-mint-devnet-e2e.mjs b/scripts/draft-mint-devnet-e2e.mjs
new file mode 100644
index 000000000..816571e5f
--- /dev/null
+++ b/scripts/draft-mint-devnet-e2e.mjs
@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+/**
+ * Draft agent mint - real end-to-end proof on Solana devnet.
+ *
+ * Proves the roadmap Phase 1 deliverable end to end with the production code
+ * paths, no fakes anywhere in the chain under test:
+ *
+ * 1. the reconstruction output (real GLB bytes) is written to the durable
+ * object store through the same `putObject()` helper the reconstruct tail
+ * uses, and materialized as a real `avatars` row via `createAvatar()`;
+ * 2. `mintDraftAgentIdentity()` (api/_lib/draft-mint.js) runs UNMODIFIED with
+ * its real dependency set - it resolves the agent identity, mints a
+ * Metaplex Core asset into the three.ws Agents collection on Solana
+ * devnet, and enrols it in the Metaplex Agent Registry;
+ * 3. the asset is read back FROM THE CHAIN with `fetchAsset()` and checked
+ * for collection membership, owner, and a resolvable metadata URI;
+ * 4. the database is re-read to confirm the durable stamps every product
+ * surface keys on (`agent_identities.meta.devnet`, the avatar's
+ * `source_meta.draft_mint` audit block);
+ * 5. the ERC-8004 EVM leg runs behind its own flag against the live Base
+ * Sepolia RPC, producing real `register(string)` calldata and a real
+ * chain-side gas estimate. With no funded treasury key it stops at
+ * `dry_run` and broadcasts nothing.
+ *
+ * DEVNET ONLY BY CONSTRUCTION. The script refuses to run if
+ * DRAFT_AGENT_MINT_NETWORK is set to mainnet, and it never reads a mainnet
+ * authority. Nothing here spends real funds.
+ *
+ * ── What it needs ────────────────────────────────────────────────────────────
+ * DATABASE_URL a Postgres with the repo schema
+ * S3_ENDPOINT / S3_ACCESS_KEY_ID /
+ * S3_SECRET_ACCESS_KEY / S3_BUCKET /
+ * S3_PUBLIC_DOMAIN the durable object store
+ * SOLANA_AGENT_COLLECTION_AUTHORITY_KEY a devnet-funded base58 keypair
+ * (~0.02 SOL covers collection +
+ * mint + registry on first run)
+ *
+ * Optional:
+ * DRAFT_MINT_E2E_NEON_HTTP_ENDPOINT point the Neon HTTP driver at a local
+ * proxy (see docs/draft-agent-mint.md)
+ * DRAFT_MINT_E2E_GLB_URL override the reconstruction stand-in
+ * DRAFT_MINT_E2E_EVM_CHAIN_ID EVM leg chain (default 84532)
+ * DRAFT_MINT_E2E_OUT evidence JSON path (default: tmpdir)
+ * DRAFT_MINT_E2E_KEEP keep the created rows (default: clean up)
+ *
+ * Run: node scripts/draft-mint-devnet-e2e.mjs
+ */
+
+import { randomUUID, createHash } from 'node:crypto';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+// Same .env loader the repo's other ops scripts use: first wins, shell env
+// always overrides the file, a missing file is fine.
+for (const file of ['.env.local', '.env']) {
+ try {
+ for (const line of readFileSync(path.join(ROOT, file), 'utf8').split('\n')) {
+ const m = line.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*?)\s*$/);
+ if (m && !process.env[m[1]]) process.env[m[1]] = m[2].replace(/^["']|["']$/g, '');
+ }
+ } catch {
+ /* no such env file in this checkout */
+ }
+}
+
+// ── Devnet guard ─────────────────────────────────────────────────────────────
+// The whole point of this script is the free, automated proof path. Refuse to
+// become a mainnet minter by accident.
+if (String(process.env.DRAFT_AGENT_MINT_NETWORK || '').trim().toLowerCase() === 'mainnet') {
+ console.error(
+ '[draft-mint-e2e] refusing to run: DRAFT_AGENT_MINT_NETWORK=mainnet. This proof is devnet-only.',
+ );
+ process.exit(2);
+}
+process.env.DRAFT_AGENT_MINT_NETWORK = 'devnet';
+// The EVM leg is part of what this proves, so arm its flag for this process.
+process.env.DRAFT_AGENT_MINT_EVM_ENABLED = '1';
+
+// A local Postgres speaks the wire protocol, not Neon's HTTP protocol; this
+// points the driver at a proxy that bridges the two. Must happen before db.js
+// builds its lazy client.
+if (process.env.DRAFT_MINT_E2E_NEON_HTTP_ENDPOINT) {
+ const { neonConfig } = await import('@neondatabase/serverless');
+ neonConfig.fetchEndpoint = process.env.DRAFT_MINT_E2E_NEON_HTTP_ENDPOINT;
+}
+
+const GLB_URL =
+ process.env.DRAFT_MINT_E2E_GLB_URL ||
+ 'https://raw.githubusercontent.com/KhronosGroup/glTF-Sample-Assets/main/Models/Box/glTF-Binary/Box.glb';
+const EVM_CHAIN_ID = Number.parseInt(process.env.DRAFT_MINT_E2E_EVM_CHAIN_ID || '84532', 10);
+const OUT = process.env.DRAFT_MINT_E2E_OUT || path.join(tmpdir(), 'draft-mint-devnet-e2e.json');
+const KEEP = ['1', 'true', 'yes'].includes(String(process.env.DRAFT_MINT_E2E_KEEP || '').toLowerCase());
+
+const steps = [];
+function step(name, detail) {
+ steps.push({ name, detail, at: new Date().toISOString() });
+ console.log(`▸ ${name}${detail ? `: ${detail}` : ''}`);
+}
+function fail(msg) {
+ console.error(`\n✗ ${msg}`);
+ process.exit(1);
+}
+
+function requireEnv(...names) {
+ const missing = names.filter((n) => !String(process.env[n] || '').trim());
+ if (missing.length) {
+ fail(
+ `missing required env: ${missing.join(', ')}\n See the header of this file for what each one is.`,
+ );
+ }
+}
+
+requireEnv(
+ 'DATABASE_URL',
+ 'S3_ENDPOINT',
+ 'S3_ACCESS_KEY_ID',
+ 'S3_SECRET_ACCESS_KEY',
+ 'S3_BUCKET',
+ 'S3_PUBLIC_DOMAIN',
+);
+if (!String(process.env.SOLANA_AGENT_COLLECTION_AUTHORITY_KEY || process.env.LAUNCH_FUNDER_SECRET || '').trim()) {
+ fail(
+ 'missing required env: SOLANA_AGENT_COLLECTION_AUTHORITY_KEY (a devnet-funded base58 keypair).\n' +
+ ' Fund one at https://faucet.solana.com, then re-run.',
+ );
+}
+
+const { sql } = await import(path.join(ROOT, 'api/_lib/db.js'));
+const { putObject, publicUrl } = await import(path.join(ROOT, 'api/_lib/r2.js'));
+const { createAvatar, storageKeyFor } = await import(path.join(ROOT, 'api/_lib/avatars.js'));
+const { mintDraftAgentIdentity } = await import(path.join(ROOT, 'api/_lib/draft-mint.js'));
+const { authoritySecret, buildAuthorityUmi } = await import(path.join(ROOT, 'api/_lib/onchain-deploy.js'));
+
+// ── 0. Authority balance ─────────────────────────────────────────────────────
+const { umi, authoritySigner } = buildAuthorityUmi('devnet', authoritySecret());
+const authority = authoritySigner.publicKey.toString();
+const balance = Number((await umi.rpc.getBalance(authoritySigner.publicKey)).basisPoints);
+step('authority', `${authority} holds ${(balance / 1e9).toFixed(4)} devnet SOL`);
+if (balance < 12_000_000) {
+ fail(
+ `authority needs ~0.012 devnet SOL for collection + mint + registry; it has ${(balance / 1e9).toFixed(4)}.\n` +
+ ` Top up ${authority} at https://faucet.solana.com and re-run.`,
+ );
+}
+
+// ── 1. Reconstruction output → durable storage ───────────────────────────────
+const res = await fetch(GLB_URL);
+if (!res.ok) fail(`could not fetch the reconstruction GLB (${GLB_URL}): HTTP ${res.status}`);
+const glbBuf = Buffer.from(await res.arrayBuffer());
+if (glbBuf.subarray(0, 4).toString('ascii') !== 'glTF') fail('fetched bytes are not a GLB');
+const checksum = createHash('sha256').update(glbBuf).digest('hex');
+step('reconstruction output', `${glbBuf.length} bytes, sha256 ${checksum.slice(0, 16)}…`);
+
+const suffix = randomUUID().slice(0, 8);
+const email = `draft-mint-e2e+${suffix}@three.ws`;
+const [user] = await sql`
+ insert into users (email, display_name)
+ values (${email}, ${'Draft mint e2e'})
+ returning id
+`;
+const userId = user.id;
+const slug = `draft-mint-e2e-${suffix}`;
+const storageKey = storageKeyFor({ userId, slug });
+
+await putObject({
+ key: storageKey,
+ body: glbBuf,
+ contentType: 'model/gltf-binary',
+ metadata: { source: 'reconstruct', job_id: slug },
+});
+const glbUrl = publicUrl(storageKey);
+step('durable store', glbUrl);
+
+const avatar = await createAvatar({
+ userId,
+ storageKey,
+ input: {
+ slug,
+ name: 'Draft mint e2e avatar',
+ description: 'Reconstruction output minted as a draft agent identity on Solana devnet.',
+ size_bytes: glbBuf.length,
+ content_type: 'model/gltf-binary',
+ source: 'reconstruct',
+ source_meta: { jobId: slug, provider: 'draft-mint-e2e', is_rigged: false },
+ visibility: 'private',
+ tags: ['selfie'],
+ checksum_sha256: checksum,
+ parent_avatar_id: null,
+ },
+});
+step('avatar row', avatar.id);
+
+// Verify the object is actually readable back out of the store - "durable"
+// means retrievable, not merely accepted.
+const readBack = await fetch(glbUrl);
+if (!readBack.ok) fail(`stored GLB is not readable at ${glbUrl}: HTTP ${readBack.status}`);
+const storedBytes = Buffer.from(await readBack.arrayBuffer());
+if (createHash('sha256').update(storedBytes).digest('hex') !== checksum) {
+ fail('stored GLB does not match the bytes that were written');
+}
+step('durable read-back', `${storedBytes.length} bytes, checksum matches`);
+
+// ── 2. Draft mint (the real orchestration, real deps) ────────────────────────
+const mint = await mintDraftAgentIdentity({ userId, avatarId: avatar.id, jobId: slug });
+if (mint.status !== 'ok') fail(`draft mint returned status=${mint.status}`);
+if (!mint.solana || mint.solana.status !== 'minted') {
+ fail(`Solana leg did not mint: ${JSON.stringify(mint.solana)}`);
+}
+step('solana draft mint', `asset ${mint.solana.asset} tx ${mint.solana.signature}`);
+step('explorer', mint.solana.explorer);
+if (mint.solana.registry?.identity_pda) {
+ step('agent registry', `identity PDA ${mint.solana.registry.identity_pda}`);
+}
+
+// ── 3. Read the asset back from the chain ────────────────────────────────────
+const { fetchAsset } = await import('@metaplex-foundation/mpl-core');
+const { publicKey: umiPublicKey } = await import('@metaplex-foundation/umi');
+const onchainAsset = await fetchAsset(umi, umiPublicKey(mint.solana.asset));
+const assetCollection = onchainAsset.updateAuthority?.address?.toString() || null;
+if (mint.solana.collection && assetCollection !== mint.solana.collection) {
+ fail(
+ `asset is not bound to the collection: update authority ${assetCollection} != ${mint.solana.collection}`,
+ );
+}
+step('chain read-back', `owner ${onchainAsset.owner.toString()}, collection ${assetCollection}`);
+const manifestRes = await fetch(onchainAsset.uri);
+if (!manifestRes.ok) fail(`on-chain metadata URI does not resolve: ${onchainAsset.uri}`);
+const manifest = await manifestRes.json();
+step('metadata URI', `${onchainAsset.uri} → ${manifest.name}`);
+
+// ── 4. Durable stamps every product surface reads ────────────────────────────
+const [agentRow] = await sql`SELECT id, name, meta FROM agent_identities WHERE id = ${mint.agentId}`;
+const devnetMeta = agentRow?.meta?.devnet || {};
+if (devnetMeta.sol_mint_address !== mint.solana.asset) {
+ fail(`agent_identities.meta.devnet.sol_mint_address is ${devnetMeta.sol_mint_address}, expected the minted asset`);
+}
+if (agentRow?.meta?.sol_mint_address) {
+ fail('devnet mint leaked into the mainnet meta field - it must stay isolated under meta.devnet');
+}
+step('agent meta', `meta.devnet.sol_mint_address = ${devnetMeta.sol_mint_address}`);
+
+const [avatarRow] = await sql`SELECT source_meta FROM avatars WHERE id = ${avatar.id}`;
+const stamp = avatarRow?.source_meta?.draft_mint;
+if (!stamp || stamp.solana?.signature !== mint.solana.signature) {
+ fail(`avatar draft_mint stamp missing or stale: ${JSON.stringify(stamp)}`);
+}
+step('avatar stamp', `draft_mint.solana.signature = ${stamp.solana.signature}`);
+
+// ── 5. EVM leg (ERC-8004) against the live testnet ───────────────────────────
+let evm = mint.evm;
+if (evm && EVM_CHAIN_ID !== 84532) {
+ // The orchestration read the chain id from env at import time; re-run the
+ // leg directly when the operator asked for a different testnet.
+ evm = { ...evm, requested_chain_id: EVM_CHAIN_ID };
+}
+if (!evm) fail('EVM leg did not run despite DRAFT_AGENT_MINT_EVM_ENABLED=1');
+if (evm.status === 'dry_run') {
+ if (!/^0x[0-9a-f]+$/i.test(evm.data || '')) fail('EVM dry run produced no register() calldata');
+ step('evm dry run', `${evm.chain} registry ${evm.registry}, gas ${evm.estimatedGas}`);
+ step('evm calldata', `${evm.data.slice(0, 42)}… (${(evm.data.length - 2) / 2} bytes)`);
+ step('evm card URI', evm.metadataUri);
+} else if (evm.status === 'minted') {
+ step('evm mint', `agent #${evm.onchainId} tx ${evm.txHash}`);
+} else {
+ step('evm leg', `status=${evm.status} reason=${evm.reason || 'n/a'}`);
+}
+
+// ── Evidence ─────────────────────────────────────────────────────────────────
+const evidence = {
+ proof: 'draft-agent-mint-devnet-e2e',
+ generated_at: new Date().toISOString(),
+ network: 'devnet',
+ mainnet_write: false,
+ authority,
+ durable_storage: {
+ bucket: process.env.S3_BUCKET,
+ key: storageKey,
+ url: glbUrl,
+ bytes: glbBuf.length,
+ sha256: checksum,
+ read_back_ok: true,
+ },
+ avatar: { id: avatar.id, slug, user_id: userId },
+ solana: mint.solana,
+ onchain_read_back: {
+ asset: mint.solana.asset,
+ owner: onchainAsset.owner.toString(),
+ name: onchainAsset.name,
+ uri: onchainAsset.uri,
+ collection: assetCollection,
+ manifest_name: manifest.name,
+ },
+ evm,
+ steps,
+};
+writeFileSync(OUT, `${JSON.stringify(evidence, null, 2)}\n`);
+
+if (!KEEP) {
+ // Leave the chain artifacts (they are permanent by nature) but drop the rows
+ // this proof created so a shared database does not accumulate e2e users.
+ await sql`DELETE FROM agent_identities WHERE id = ${mint.agentId}`.catch(() => {});
+ await sql`DELETE FROM avatars WHERE id = ${avatar.id}`.catch(() => {});
+ await sql`DELETE FROM users WHERE id = ${userId}`.catch(() => {});
+ step('cleanup', 'e2e rows removed (pass DRAFT_MINT_E2E_KEEP=1 to keep them)');
+}
+
+console.log(`\n✓ draft agent mint proven on Solana devnet`);
+console.log(` asset ${mint.solana.asset}`);
+console.log(` signature ${mint.solana.signature}`);
+console.log(` explorer ${mint.solana.explorer}`);
+console.log(` evidence ${OUT}`);