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.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
// Real-funds agreement gate: pure logic + storage and network behavior of
// public/risk-ack.js. The DOM dialog itself is exercised in the browser; these
// tests pin down what decides whether a person gets prompted and what a
// signature sends: record parsing, version currency, signature validation, the
// server-status cross-check, the degraded signing path, and fetchWithRiskAck.
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
async function load() {
vi.resetModules();
return import('../public/risk-ack.js');
}
function fakeStorage(initial = {}) {
const map = new Map(Object.entries(initial));
return {
getItem: (k) => (map.has(k) ? map.get(k) : null),
setItem: (k, v) => map.set(k, String(v)),
removeItem: (k) => map.delete(k),
_map: map,
};
}
function jsonResponse(status, body) {
return new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } });
}
const saved = {};
beforeEach(() => {
for (const k of ['localStorage', 'fetch', 'confirm', 'prompt', 'alert', 'document']) saved[k] = globalThis[k];
delete globalThis.document;
});
afterEach(() => {
for (const [k, v] of Object.entries(saved)) {
if (v === undefined) delete globalThis[k];
else globalThis[k] = v;
}
});
describe('pure helpers', () => {
it('parseAckRecord parses a valid record and rejects garbage', async () => {
const { parseAckRecord } = await load();
expect(parseAckRecord(JSON.stringify({ version: 2, acceptedAt: '2026-09-17T12:00:00.000Z', context: 'trade' }))).toEqual({
version: 2,
acceptedAt: '2026-09-17T12:00:00.000Z',
context: 'trade',
});
for (const raw of [null, '', 'not json', '42', JSON.stringify({ version: 0, acceptedAt: '2026-01-01' }), JSON.stringify({ version: 1.5, acceptedAt: '2026-01-01' }), JSON.stringify({ version: 2 })]) {
expect(parseAckRecord(raw)).toBeNull();
}
});
it('isAckCurrent: a version-1 acknowledgment no longer counts after the bump to the signature bundle', async () => {
const { isAckCurrent, RISK_ACK_VERSION } = await load();
expect(RISK_ACK_VERSION).toBeGreaterThanOrEqual(2);
expect(isAckCurrent({ version: 1 })).toBe(false);
expect(isAckCurrent({ version: RISK_ACK_VERSION })).toBe(true);
expect(isAckCurrent(null)).toBe(false);
});
it('normalizeSignatureName accepts real names and refuses non-signatures', async () => {
const { normalizeSignatureName, SIGNATURE_NAME_MAX } = await load();
expect(normalizeSignatureName(' Ada Lovelace ')).toBe('Ada Lovelace');
expect(normalizeSignatureName('李小龙')).toBe('李小龙');
expect(normalizeSignatureName('Zoë O’Brien')).toBe('Zoë O’Brien');
expect(normalizeSignatureName('A')).toBeNull();
expect(normalizeSignatureName('12345')).toBeNull();
expect(normalizeSignatureName(' ')).toBeNull();
expect(normalizeSignatureName('x'.repeat(SIGNATURE_NAME_MAX + 1))).toBeNull();
expect(normalizeSignatureName(42)).toBeNull();
});
it('buildSignaturePayload covers every document and attestation at the current versions', async () => {
const { buildSignaturePayload, AGREEMENT_DOCUMENTS, AGREEMENT_ATTESTATIONS, RISK_ACK_VERSION } = await load();
const p = buildSignaturePayload({ name: 'Ada Lovelace', context: 'deposit', path: '/agents/x' });
expect(p.version).toBe(RISK_ACK_VERSION);
expect(Object.keys(p.documents).sort()).toEqual(AGREEMENT_DOCUMENTS.map((d) => d.key).sort());
for (const d of AGREEMENT_DOCUMENTS) expect(p.documents[d.key]).toBe(d.version);
for (const a of AGREEMENT_ATTESTATIONS) expect(p.attestations[a.key]).toBe(true);
expect(p).toMatchObject({ signatureName: 'Ada Lovelace', context: 'deposit', path: '/agents/x' });
});
it('the documents are exactly the Terms, the Risk Disclosure, and the Agent Wallet Agreement', async () => {
const { AGREEMENT_DOCUMENTS } = await load();
expect(AGREEMENT_DOCUMENTS.map((d) => d.path)).toEqual(['/legal/tos', '/legal/risk', '/legal/agent-wallet']);
});
it('isRiskAckRequiredError recognizes only the server refusal', async () => {
const { isRiskAckRequiredError } = await load();
expect(isRiskAckRequiredError({ error: 'risk_ack_required' })).toBe(true);
expect(isRiskAckRequiredError({ error: 'forbidden' })).toBe(false);
expect(isRiskAckRequiredError(null)).toBe(false);
});
});
describe('hasRiskAck / ensureRiskAck', () => {
it('a current local signature with no session passes without prompting', async () => {
const m = await load();
globalThis.localStorage = fakeStorage({
[m.RISK_ACK_STORAGE_KEY]: JSON.stringify({ version: m.RISK_ACK_VERSION, acceptedAt: '2026-09-17T00:00:00.000Z' }),
});
globalThis.fetch = vi.fn(async () => jsonResponse(200, { authenticated: false, signed: false, version: m.RISK_ACK_VERSION }));
await expect(m.ensureRiskAck({ context: 'trade' })).resolves.toBe(true);
});
it('a local signature does not stand in for a signed-in account the server says is unsigned', async () => {
const m = await load();
const storage = fakeStorage({
[m.RISK_ACK_STORAGE_KEY]: JSON.stringify({ version: m.RISK_ACK_VERSION, acceptedAt: '2026-09-17T00:00:00.000Z' }),
});
globalThis.localStorage = storage;
globalThis.fetch = vi.fn(async () => jsonResponse(200, { authenticated: true, signed: false, version: m.RISK_ACK_VERSION }));
// No DOM in Node: the gate must fail CLOSED and drop the stale local record.
await expect(m.ensureRiskAck({ context: 'trade' })).resolves.toBe(false);
expect(storage.getItem(m.RISK_ACK_STORAGE_KEY)).toBeNull();
});
it('an unreachable status endpoint falls back to the local record (the server still enforces)', async () => {
const m = await load();
globalThis.localStorage = fakeStorage({
[m.RISK_ACK_STORAGE_KEY]: JSON.stringify({ version: m.RISK_ACK_VERSION, acceptedAt: '2026-09-17T00:00:00.000Z' }),
});
globalThis.fetch = vi.fn(async () => {
throw new Error('offline');
});
await expect(m.hasRiskAckVerified()).resolves.toBe(true);
});
it('no signature and no DOM resolves false', async () => {
const m = await load();
globalThis.localStorage = fakeStorage();
await expect(m.ensureRiskAck({ context: 'trade' })).resolves.toBe(false);
await expect(m.hasRiskAckVerified()).resolves.toBe(false);
});
it('hasRiskAck survives a throwing localStorage', async () => {
const m = await load();
globalThis.localStorage = {
getItem() {
throw new Error('denied');
},
};
expect(m.hasRiskAck()).toBe(false);
});
});
describe('fallbackConfirmAck: signing when the dialog cannot render', () => {
it('records a full signature and persists it only after the server stored it', async () => {
const m = await load();
globalThis.localStorage = fakeStorage();
globalThis.confirm = () => true;
globalThis.prompt = () => ' Ada Lovelace ';
const calls = [];
globalThis.fetch = vi.fn(async (url, init) => {
calls.push({ url: String(url), init });
return jsonResponse(200, { ok: true, recorded: true, version: m.RISK_ACK_VERSION });
});
await expect(m.fallbackConfirmAck({ context: 'swap' })).resolves.toBe(true);
expect(calls).toHaveLength(1);
expect(calls[0].init.method).toBe('POST');
const body = JSON.parse(calls[0].init.body);
expect(body).toMatchObject({ version: m.RISK_ACK_VERSION, signatureName: 'Ada Lovelace', context: 'swap' });
const rec = m.parseAckRecord(globalThis.localStorage.getItem(m.RISK_ACK_STORAGE_KEY));
expect(m.isAckCurrent(rec)).toBe(true);
});
it('an unrecorded signature is not treated as signed', async () => {
const m = await load();
globalThis.localStorage = fakeStorage();
globalThis.confirm = () => true;
globalThis.prompt = () => 'Ada Lovelace';
globalThis.alert = vi.fn();
globalThis.fetch = vi.fn(async () => jsonResponse(503, { error: 'signature_not_recorded', error_description: 'db down' }));
await expect(m.fallbackConfirmAck({ context: 'trade' })).resolves.toBe(false);
expect(globalThis.localStorage.getItem(m.RISK_ACK_STORAGE_KEY)).toBeNull();
expect(globalThis.alert).toHaveBeenCalled();
});
it('cancelling, an empty name, or a missing confirm() all fail closed and send nothing', async () => {
const m = await load();
globalThis.localStorage = fakeStorage();
globalThis.fetch = vi.fn();
globalThis.confirm = () => false;
await expect(m.fallbackConfirmAck()).resolves.toBe(false);
globalThis.confirm = () => true;
globalThis.prompt = () => '';
await expect(m.fallbackConfirmAck()).resolves.toBe(false);
delete globalThis.confirm;
await expect(m.fallbackConfirmAck()).resolves.toBe(false);
expect(globalThis.fetch).not.toHaveBeenCalled();
});
it('a throwing confirm() cannot break the caller', async () => {
const m = await load();
globalThis.confirm = () => {
throw new Error('blocked');
};
await expect(m.fallbackConfirmAck()).resolves.toBe(false);
});
});
describe('fetchWithRiskAck', () => {
it('passes through anything that is not a risk_ack_required refusal', async () => {
const m = await load();
globalThis.fetch = vi.fn(async () => jsonResponse(403, { error: 'forbidden' }));
const res = await m.fetchWithRiskAck('/api/x', { method: 'POST' });
expect(res.status).toBe(403);
expect(globalThis.fetch).toHaveBeenCalledTimes(1);
});
it('returns the refusal untouched when the person does not sign', async () => {
const m = await load();
globalThis.localStorage = fakeStorage();
globalThis.fetch = vi.fn(async () => jsonResponse(403, { error: 'risk_ack_required' }));
const res = await m.fetchWithRiskAck('/api/x', { method: 'POST' });
expect(res.status).toBe(403);
expect(globalThis.fetch).toHaveBeenCalledTimes(1);
});
});