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.

6.5 KB
Raw Blame
// Server-side checkout tests — pure logic, no network required.
//
//   npm test    (from the package root)
//
// `prepareSolanaCheckout` validates its input *before* any RPC round-trip, so we
// can assert the validation paths without a live Solana connection. `encode` is
// fully offline.

import { test } from 'node:test';
import assert from 'node:assert/strict';

import {
	encodeX402Payment,
	prepareSolanaCheckout,
	handleCheckout,
	isSolanaNetwork,
	CheckoutError,
	NETWORK_SOLANA_MAINNET,
	NETWORK_SOLANA_DEVNET,
	solanaAccept,
	THREE_MINT,
	USDC_MINT_SOLANA,
} from '../server/checkout.js';

const USDC_MAINNET = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
// Clearly-synthetic placeholder addresses (valid base58, 32-44 chars).
const PAY_TO = '11111111111111111111111111111112';
const FEE_PAYER = 'So11111111111111111111111111111111111111112';
const BUYER = 'So11111111111111111111111111111111111111112';

function accept(overrides = {}) {
	return {
		scheme: 'exact',
		network: NETWORK_SOLANA_MAINNET,
		amount: '10000',
		asset: USDC_MAINNET,
		payTo: PAY_TO,
		extra: { name: 'USDC', decimals: 6, feePayer: FEE_PAYER },
		...overrides,
	};
}

test('isSolanaNetwork recognizes the CAIP-2 ids and the bare alias', () => {
	assert.ok(isSolanaNetwork(NETWORK_SOLANA_MAINNET));
	assert.ok(isSolanaNetwork(NETWORK_SOLANA_DEVNET));
	assert.ok(isSolanaNetwork('solana'));
	assert.ok(!isSolanaNetwork('eip155:8453'));
});

test('solanaAccept builds a USDC accept from uiAmount', () => {
	const a = solanaAccept({ token: 'usdc', uiAmount: '0.25', payTo: PAY_TO, feePayer: FEE_PAYER });
	assert.equal(a.scheme, 'exact');
	assert.equal(a.network, NETWORK_SOLANA_MAINNET);
	assert.equal(a.asset, USDC_MINT_SOLANA);
	assert.equal(a.amount, '250000'); // 0.25 * 1e6
	assert.equal(a.payTo, PAY_TO);
	assert.equal(a.extra.name, 'USD Coin');
	assert.equal(a.extra.decimals, 6);
	assert.equal(a.extra.feePayer, FEE_PAYER);
});

test('solanaAccept builds a THREE accept and carries the canonical mint', () => {
	const a = solanaAccept({ token: 'three', uiAmount: 1000, payTo: PAY_TO, feePayer: FEE_PAYER });
	assert.equal(a.asset, THREE_MINT);
	assert.equal(a.amount, '1000000000'); // 1000 * 1e6
	assert.equal(a.extra.name, 'THREE');
	// The prepare path accepts what solanaAccept emits without further wiring.
	assert.doesNotThrow(() => encodeX402Payment({ accept: a, signedTxBase64: 'A'.repeat(80), resourceUrl: 'https://example.com/x' }));
});

test('solanaAccept accepts an explicit mint + atomic amount', () => {
	const mint = 'So11111111111111111111111111111111111111112';
	const a = solanaAccept({ mint, amount: '12345', decimals: 9, name: 'Custom', payTo: PAY_TO, feePayer: FEE_PAYER });
	assert.equal(a.asset, mint);
	assert.equal(a.amount, '12345');
	assert.equal(a.extra.decimals, 9);
	assert.equal(a.extra.name, 'Custom');
});

test('solanaAccept rejects an unknown token and a missing amount', () => {
	assert.throws(() => solanaAccept({ token: 'sol', payTo: PAY_TO, feePayer: FEE_PAYER, uiAmount: 1 }), CheckoutError);
	assert.throws(() => solanaAccept({ token: 'usdc', payTo: PAY_TO, feePayer: FEE_PAYER }), CheckoutError);
	assert.throws(() => solanaAccept({ token: 'usdc', uiAmount: 'abc', payTo: PAY_TO, feePayer: FEE_PAYER }), CheckoutError);
});

test('encodeX402Payment produces a decodable v2 envelope', () => {
	const { x_payment } = encodeX402Payment({
		accept: accept(),
		signedTxBase64: 'A'.repeat(80),
		resourceUrl: 'https://example.com/api/paid',
	});
	const decoded = JSON.parse(Buffer.from(x_payment, 'base64').toString('utf8'));
	assert.equal(decoded.x402Version, 2);
	assert.equal(decoded.scheme, 'exact');
	assert.equal(decoded.network, NETWORK_SOLANA_MAINNET);
	assert.equal(decoded.resource.url, 'https://example.com/api/paid');
	assert.equal(decoded.payload.transaction, 'A'.repeat(80));
	assert.equal(decoded.extensions, undefined);
});

test('encodeX402Payment echoes a valid builder-code and drops a bad one', () => {
	const good = encodeX402Payment({
		accept: accept(),
		signedTxBase64: 'A'.repeat(80),
		resourceUrl: 'https://example.com/api/paid',
		builderCode: { a: 'agentic', w: 'acme', s: ['acme_checkout', 'BAD CODE!'] },
	});
	const decoded = JSON.parse(Buffer.from(good.x_payment, 'base64').toString('utf8'));
	assert.deepEqual(decoded.extensions['builder-code'], { a: 'agentic', w: 'acme', s: ['acme_checkout'] });

	const noA = encodeX402Payment({
		accept: accept(),
		signedTxBase64: 'A'.repeat(80),
		resourceUrl: 'https://example.com/api/paid',
		builderCode: { w: 'acme' }, // missing required `a`
	});
	const decodedNoA = JSON.parse(Buffer.from(noA.x_payment, 'base64').toString('utf8'));
	assert.equal(decodedNoA.extensions, undefined);
});

test('encodeX402Payment rejects a relative resource url', () => {
	assert.throws(
		() => encodeX402Payment({ accept: accept(), signedTxBase64: 'A'.repeat(80), resourceUrl: '/relative' }),
		(e) => e instanceof CheckoutError && e.status === 400,
	);
});

test('prepareSolanaCheckout rejects an EVM network before any RPC call', async () => {
	await assert.rejects(
		prepareSolanaCheckout({ accept: accept({ network: 'eip155:8453' }), buyer: BUYER }),
		(e) => e instanceof CheckoutError && e.code === 'unsupported_network',
	);
});

test('prepareSolanaCheckout rejects a bad buyer address before any RPC call', async () => {
	await assert.rejects(
		prepareSolanaCheckout({ accept: accept(), buyer: 'not-a-pubkey' }),
		(e) => e instanceof CheckoutError && e.code === 'invalid_request',
	);
});

test('prepareSolanaCheckout requires a fee payer', async () => {
	await assert.rejects(
		prepareSolanaCheckout({ accept: accept({ extra: { name: 'USDC', decimals: 6 } }), buyer: BUYER }),
		(e) => e instanceof CheckoutError && e.code === 'invalid_request',
	);
});

test('handleCheckout routes encode and returns 200', async () => {
	const res = await handleCheckout({
		action: 'encode',
		body: {
			accept: accept(),
			signed_tx_base64: 'A'.repeat(80),
			resource_url: 'https://example.com/api/paid',
		},
	});
	assert.equal(res.status, 200);
	assert.ok(typeof res.body.x_payment === 'string');
});

test('handleCheckout 404s an unknown action', async () => {
	const res = await handleCheckout({ action: 'bogus', body: {} });
	assert.equal(res.status, 404);
	assert.equal(res.body.error, 'not_found');
});

test('handleCheckout maps a CheckoutError to its status', async () => {
	const res = await handleCheckout({
		action: 'prepare',
		body: { accept: accept({ network: 'eip155:8453' }), buyer: BUYER },
	});
	assert.equal(res.status, 400);
	assert.equal(res.body.error, 'unsupported_network');
});