create-x402-conflux-app 0.1.0

package/dist/finalize.d.ts

@@ -0,0 +1,2 @@
+import type { WizardAnswers } from './wizard.js';
+export declare function finalize(targetDir: string, answers: WizardAnswers): Promise<void>;

package/dist/finalize.js

@@ -0,0 +1,45 @@
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+import { spinner, outro, note } from '@clack/prompts';
+import pc from 'picocolors';
+export async function finalize(targetDir, answers) {
+    const s = spinner();
+    const projectName = path.basename(targetDir);
+    // 1. Git init
+    s.start('Initializing git repository...');
+    try {
+        execSync('git init', { cwd: targetDir, stdio: 'ignore' });
+        s.stop('Git repository initialized');
+    }
+    catch {
+        s.stop('Skipped git init');
+    }
+    // 2. Install dependencies
+    const pm = answers.packageManager;
+    s.start(`Installing dependencies with ${pm}...`);
+    try {
+        const installCmd = pm === 'yarn' ? 'yarn install' : `${pm} install`;
+        execSync(installCmd, { cwd: targetDir, stdio: 'ignore', timeout: 120_000 });
+        s.stop('Dependencies installed');
+    }
+    catch {
+        s.stop(`Could not install dependencies — run ${pc.cyan(`${pm} install`)} manually`);
+    }
+    // 3. Next steps
+    const steps = [
+        `cd ${projectName}`,
+        'cp .env.example .env     # Fill in your private keys',
+        `${pm === 'npm' ? 'npm run' : pm} build               # Build all packages`,
+        `${pm === 'npm' ? 'npm run' : pm} dev:facilitator     # Start facilitator (terminal 1)`,
+        `${pm === 'npm' ? 'npm run' : pm} dev:server          # Start server (terminal 2)`,
+        `${pm === 'npm' ? 'npm run' : pm} start:client        # Run client (terminal 3)`,
+    ];
+    if (answers.includeIdentity) {
+        steps.push('');
+        steps.push('Identity setup:');
+        steps.push(`  ${pm === 'npm' ? 'npm run' : pm} test:contracts      # Run contract tests`);
+        steps.push(`  ${pm === 'npm' ? 'npm run' : pm} deploy:contracts    # Deploy to Conflux eSpace`);
+    }
+    note(steps.join('\n'), 'Next steps');
+    outro(pc.green(`Project created at ./${projectName}`));
+}

package/dist/generator.d.ts

@@ -0,0 +1,2 @@
+import type { WizardAnswers } from './wizard.js';
+export declare function generate(answers: WizardAnswers): Promise<string>;

package/dist/generator.js

@@ -0,0 +1,120 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spinner } from '@clack/prompts';
+import { copyDir, substituteInDir } from './utils.js';
+import { patchServerConfig, patchServerApp, patchClientConfig, patchClientPayAndFetch, patchEnvExample, patchRootPackageJson, patchPnpmWorkspace, } from './patches.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function getTemplatesDir() {
+    // In development (src/), templates are at ../templates
+    // In dist (dist/), templates are at ../templates
+    const dir = path.resolve(__dirname, '..', 'templates');
+    if (!fs.existsSync(dir)) {
+        throw new Error(`Templates directory not found at ${dir}`);
+    }
+    return dir;
+}
+export async function generate(answers) {
+    const s = spinner();
+    s.start('Generating project...');
+    const targetDir = path.resolve(process.cwd(), answers.projectName);
+    if (fs.existsSync(targetDir)) {
+        const entries = fs.readdirSync(targetDir);
+        if (entries.length > 0) {
+            throw new Error(`Directory ${answers.projectName} already exists and is not empty`);
+        }
+    }
+    const templatesDir = getTemplatesDir();
+    const baseDir = path.join(templatesDir, 'base');
+    const identityDir = path.join(templatesDir, 'identity');
+    // 1. Copy base templates
+    copyDir(baseDir, targetDir);
+    // 2. Copy identity overlay if needed
+    if (answers.includeIdentity) {
+        copyDir(identityDir, targetDir);
+    }
+    // 3. Apply patches when identity is included, otherwise strip markers
+    if (answers.includeIdentity) {
+        applyPatches(targetDir);
+    }
+    else {
+        stripIdentityMarkers(targetDir);
+    }
+    // 4. Variable substitution
+    const vars = {
+        PROJECT_NAME: answers.projectName,
+        CHAIN_ID: String(answers.chainId),
+        RPC_URL: answers.rpcUrl,
+        NETWORK_CAIP2: `eip155:${answers.chainId}`,
+        AUTH_MODE: answers.authMode,
+    };
+    substituteInDir(targetDir, vars);
+    s.stop('Project generated!');
+    return targetDir;
+}
+function stripIdentityMarkers(targetDir) {
+    const filesToClean = [
+        'packages/server/src/config.ts',
+        'packages/server/src/app.ts',
+        'packages/client/src/config.ts',
+        'packages/client/src/pay-and-fetch.ts',
+        '.env.example',
+        'package.json',
+    ];
+    for (const file of filesToClean) {
+        const filePath = path.join(targetDir, file);
+        if (fs.existsSync(filePath)) {
+            let content = fs.readFileSync(filePath, 'utf-8');
+            // Remove lines containing identity markers
+            content = content
+                .split('\n')
+                .filter((line) => !line.includes('{{IDENTITY_'))
+                .join('\n');
+            // Fix trailing commas in JSON (e.g. after removing last property)
+            if (file.endsWith('.json')) {
+                content = content.replace(/,(\s*[}\]])/g, '$1');
+            }
+            fs.writeFileSync(filePath, content);
+        }
+    }
+}
+function applyPatches(targetDir) {
+    const patches = [
+        {
+            file: 'packages/server/src/config.ts',
+            patch: patchServerConfig,
+        },
+        {
+            file: 'packages/server/src/app.ts',
+            patch: patchServerApp,
+        },
+        {
+            file: 'packages/client/src/config.ts',
+            patch: patchClientConfig,
+        },
+        {
+            file: 'packages/client/src/pay-and-fetch.ts',
+            patch: patchClientPayAndFetch,
+        },
+        {
+            file: '.env.example',
+            patch: patchEnvExample,
+        },
+        {
+            file: 'package.json',
+            patch: patchRootPackageJson,
+        },
+        {
+            file: 'pnpm-workspace.yaml',
+            patch: patchPnpmWorkspace,
+        },
+    ];
+    for (const { file, patch } of patches) {
+        const filePath = path.join(targetDir, file);
+        if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const patched = patch(content);
+            fs.writeFileSync(filePath, patched);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { intro, outro, log } from '@clack/prompts';
+import pc from 'picocolors';
+import { runWizard } from './wizard.js';
+import { generate } from './generator.js';
+import { finalize } from './finalize.js';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+const args = process.argv.slice(2);
+if (args.includes('--version') || args.includes('-v')) {
+    console.log(pkg.version);
+    process.exit(0);
+}
+if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+  ${pc.bold('create-x402-app')} v${pkg.version}
+
+  Scaffold a Conflux x402 payment project.
+
+  ${pc.dim('Usage:')}
+    npx create-x402-app
+    npx create-x402-app --version
+    npx create-x402-app --help
+`);
+    process.exit(0);
+}
+async function main() {
+    intro(pc.bgCyan(pc.black(' create-x402-app ')));
+    const answers = await runWizard();
+    if (!answers) {
+        outro(pc.dim('Setup cancelled.'));
+        process.exit(0);
+    }
+    const targetDir = await generate(answers);
+    await finalize(targetDir, answers);
+}
+main().catch((err) => {
+    log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/patches.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Patch functions that modify base template files when identity overlay is active.
+ * Each function receives the base file content and returns modified content.
+ * Base templates contain marker comments (e.g. // {{IDENTITY_IMPORTS}}) that
+ * patches replace with actual code.
+ */
+export declare function patchServerConfig(content: string): string;
+export declare function patchServerApp(content: string): string;
+export declare function patchClientConfig(content: string): string;
+export declare function patchClientPayAndFetch(content: string): string;
+export declare function patchEnvExample(content: string): string;
+export declare function patchRootPackageJson(content: string): string;
+export declare function patchPnpmWorkspace(_content: string): string;

package/dist/patches.js

@@ -0,0 +1,104 @@
+/**
+ * Patch functions that modify base template files when identity overlay is active.
+ * Each function receives the base file content and returns modified content.
+ * Base templates contain marker comments (e.g. // {{IDENTITY_IMPORTS}}) that
+ * patches replace with actual code.
+ */
+export function patchServerConfig(content) {
+    return content
+        .replace('// {{IDENTITY_CONFIG_FIELDS}}', `  // Auth gate
+  identityRegistryAddress: z.string().startsWith('0x').optional(),
+  rpcUrl: z.string().url().default('{{RPC_URL}}'),
+  chainId: z.coerce.number().default({{CHAIN_ID}}),`)
+        .replace('// {{IDENTITY_ENV_PARSE}}', `    identityRegistryAddress: process.env.IDENTITY_REGISTRY_ADDRESS,
+    rpcUrl: process.env.RPC_URL,
+    chainId: process.env.CHAIN_ID,`)
+        .replace('// {{IDENTITY_VALIDATION}}', `  if (config.authMode === 'domain_gate' && !config.identityRegistryAddress) {
+    throw new Error('IDENTITY_REGISTRY_ADDRESS is required when AUTH_MODE=domain_gate')
+  }`);
+}
+export function patchServerApp(content) {
+    return content
+        .replace('// {{IDENTITY_IMPORTS}}', `import { createPublicClient, http } from 'viem'
+import { confluxESpace } from '@{{PROJECT_NAME}}/chain-config'
+import { createAuthCheckMiddleware } from './middleware/auth-check.js'`)
+        .replace('  // {{IDENTITY_MIDDLEWARE}}', `  // Setup auth gate middleware (before x402)
+  if (config.authMode !== 'none') {
+    const publicClient = createPublicClient({
+      chain: confluxESpace,
+      transport: http(config.rpcUrl),
+    })
+
+    app.use(createAuthCheckMiddleware({ config, publicClient }))
+    logger.info(
+      { authMode: config.authMode, registryAddress: config.identityRegistryAddress },
+      'auth gate enabled',
+    )
+  } else {
+    logger.info('auth gate disabled (AUTH_MODE=none)')
+  }
+`);
+}
+export function patchClientConfig(content) {
+    return content
+        .replace('// {{IDENTITY_CONFIG_FIELDS}}', `  authEnabled: z
+    .string()
+    .transform((v) => v === 'true')
+    .default('false'),
+  chainId: z.coerce.number().default({{CHAIN_ID}}),`)
+        .replace('// {{IDENTITY_ENV_PARSE}}', `    authEnabled: process.env.AUTH_ENABLED,
+    chainId: process.env.CHAIN_ID,`);
+}
+export function patchClientPayAndFetch(content) {
+    return content
+        .replace('// {{IDENTITY_IMPORTS}}', `import { signRequest } from './sign-request.js'`)
+        .replace('  // {{IDENTITY_FETCH_WRAP}}', `  // Wrap fetch to add auth headers when enabled
+  const fetchWithPay = config.authEnabled
+    ? async (url: string | URL | Request, init?: RequestInit) => {
+        const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url
+        const method = init?.method ?? 'GET'
+        const body = init?.body ? String(init.body) : undefined
+
+        const authHeaders = await signRequest(viemClient, {
+          method,
+          url: urlStr,
+          body,
+          chainId: config.chainId,
+        })
+
+        const mergedInit: RequestInit = {
+          ...init,
+          headers: {
+            ...Object.fromEntries(new Headers(init?.headers).entries()),
+            ...authHeaders,
+          },
+        }
+
+        return baseFetchWithPay(url, mergedInit)
+      }
+    : baseFetchWithPay`);
+}
+export function patchEnvExample(content) {
+    return content.replace('# {{IDENTITY_ENV_VARS}}', `# ===== Client Auth =====
+AUTH_ENABLED=false                  # true = sign requests (required when AUTH_MODE=domain_gate)
+
+# ===== Identity Gating Contracts =====
+ZK_VERIFIER_ADDRESS=0x...           # ZKVerifier contract address (from deployment)
+
+# ===== Attestor Service =====
+ATTESTOR_PRIVATE_KEY=0x...          # Attestor private key for signing attestations
+ATTESTOR_URL=http://localhost:3003
+PORT=3003
+DEFAULT_EXPIRY_SECONDS=2592000
+MOCK_MODE=false`);
+}
+export function patchRootPackageJson(content) {
+    // Insert identity-related scripts into the root package.json
+    return content.replace('"// {{IDENTITY_SCRIPTS}}": ""', `"dev:attestor": "pnpm --filter @{{PROJECT_NAME}}/attestor dev",
+    "test:contracts": "pnpm --filter @{{PROJECT_NAME}}/contracts test",
+    "deploy:contracts": "pnpm --filter @{{PROJECT_NAME}}/contracts deploy"`);
+}
+export function patchPnpmWorkspace(_content) {
+    // The base already has packages/* which covers identity packages
+    return _content;
+}

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function isTextFile(filePath: string): boolean;
+export declare function substituteVars(content: string, vars: Record<string, string>): string;
+export declare function copyDir(src: string, dest: string): void;
+export declare function substituteInDir(dir: string, vars: Record<string, string>): void;

package/dist/utils.js

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const TEXT_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.txt',
+    '.yaml', '.yml', '.toml', '.env', '.gitignore', '.sol',
+    '.css', '.html', '.sh', '.mjs', '.cjs',
+]);
+export function isTextFile(filePath) {
+    const ext = path.extname(filePath);
+    if (TEXT_EXTENSIONS.has(ext))
+        return true;
+    // Files without extensions (like .gitignore, .env.example) are text
+    const basename = path.basename(filePath);
+    if (basename.startsWith('.') || basename.includes('.example'))
+        return true;
+    return false;
+}
+export function substituteVars(content, vars) {
+    let result = content;
+    for (const [key, value] of Object.entries(vars)) {
+        result = result.replaceAll(`{{${key}}}`, value);
+    }
+    return result;
+}
+export function copyDir(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDir(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+export function substituteInDir(dir, vars) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            substituteInDir(fullPath, vars);
+        }
+        else if (isTextFile(fullPath)) {
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            const substituted = substituteVars(content, vars);
+            if (substituted !== content) {
+                fs.writeFileSync(fullPath, substituted);
+            }
+        }
+    }
+}

package/dist/wizard.d.ts

@@ -0,0 +1,10 @@
+export interface WizardAnswers {
+    projectName: string;
+    network: 'mainnet' | 'testnet';
+    chainId: number;
+    rpcUrl: string;
+    authMode: 'none' | 'domain_gate';
+    includeIdentity: boolean;
+    packageManager: 'pnpm' | 'npm' | 'yarn';
+}
+export declare function runWizard(): Promise<WizardAnswers | undefined>;

package/dist/wizard.js

@@ -0,0 +1,83 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+const VALID_DIR_RE = /^[a-zA-Z0-9_@][a-zA-Z0-9._@/-]*$/;
+export async function runWizard() {
+    const answers = await p.group({
+        projectName: () => p.text({
+            message: 'Project name',
+            placeholder: 'my-x402-app',
+            defaultValue: 'my-x402-app',
+            validate(value) {
+                if (!value)
+                    return 'Project name is required';
+                if (!VALID_DIR_RE.test(value))
+                    return 'Invalid directory name';
+            },
+        }),
+        network: () => p.select({
+            message: 'Which network?',
+            options: [
+                {
+                    value: 'testnet',
+                    label: `Conflux eSpace Testnet ${pc.dim('(chainId: 71)')}`,
+                    hint: 'recommended for development',
+                },
+                {
+                    value: 'mainnet',
+                    label: `Conflux eSpace Mainnet ${pc.dim('(chainId: 1030)')}`,
+                },
+            ],
+        }),
+        authMode: () => p.select({
+            message: 'Authentication mode',
+            options: [
+                {
+                    value: 'none',
+                    label: 'None',
+                    hint: 'pure x402 payments, no identity gate',
+                },
+                {
+                    value: 'domain_gate',
+                    label: 'Domain gate',
+                    hint: 'wallet signature + on-chain identity registry',
+                },
+            ],
+        }),
+        includeIdentity: ({ results }) => {
+            if (results.authMode !== 'domain_gate') {
+                return Promise.resolve(false);
+            }
+            return p.confirm({
+                message: 'Include identity contracts, attestor & CLI packages?',
+                initialValue: true,
+            });
+        },
+        packageManager: () => p.select({
+            message: 'Package manager',
+            options: [
+                { value: 'pnpm', label: 'pnpm', hint: 'recommended' },
+                { value: 'npm', label: 'npm' },
+                { value: 'yarn', label: 'yarn' },
+            ],
+        }),
+    }, {
+        onCancel() {
+            return undefined;
+        },
+    });
+    if (p.isCancel(answers))
+        return undefined;
+    const chainId = answers.network === 'mainnet' ? 1030 : 71;
+    const rpcUrl = answers.network === 'mainnet'
+        ? 'https://evm.confluxrpc.com'
+        : 'https://evmtestnet.confluxrpc.com';
+    return {
+        projectName: answers.projectName,
+        network: answers.network,
+        chainId,
+        rpcUrl,
+        authMode: answers.authMode,
+        includeIdentity: answers.includeIdentity,
+        packageManager: answers.packageManager,
+    };
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "create-x402-conflux-app",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Scaffold CLI for Conflux x402 payment projects",
+  "bin": {
+    "create-x402-app": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build && npm pack --dry-run"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "tsx": "^4.19.0",
+    "@types/node": "^20.0.0"
+  }
+}

package/templates/base/.env.example

@@ -0,0 +1,30 @@
+# ===== Facilitator =====
+FACILITATOR_PRIVATE_KEY=0x...      # Facilitator wallet private key (needs CFX for gas)
+FACILITATOR_PORT=4022
+
+# ===== Settlement =====
+VERIFY_ONLY_MODE=true              # true = signature check only, false = real settlement
+
+# ===== Safety Controls =====
+MAX_PER_TRANSACTION=1.0             # Per-tx limit (USD)
+MAX_DAILY_TOTAL=10.0                # Daily total limit (USD)
+GAS_BUFFER_PERCENT=50               # Gas estimate buffer % (Conflux needs ~50%)
+
+# ===== Server =====
+SERVER_PORT=4021
+FACILITATOR_URL=http://localhost:4022
+EVM_ADDRESS=0x...                   # payTo address (receives USDT0)
+PAYMENT_ENABLED=true
+
+# ===== Server Auth Gate =====
+AUTH_MODE={{AUTH_MODE}}
+IDENTITY_REGISTRY_ADDRESS=0x...     # Required when AUTH_MODE=domain_gate
+
+# ===== Service-to-Service Auth =====
+FACILITATOR_API_KEY=                # Leave empty to disable
+
+# ===== Client =====
+CLIENT_PRIVATE_KEY=0x...            # Payer wallet private key (needs USDT0 balance)
+SERVER_URL=http://localhost:4021
+
+# {{IDENTITY_ENV_VARS}}

package/templates/base/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Conflux eSpace x402 payment project",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "pnpm -r build",
+    "dev:facilitator": "pnpm --filter @{{PROJECT_NAME}}/facilitator dev",
+    "dev:server": "pnpm --filter @{{PROJECT_NAME}}/server dev",
+    "start:client": "pnpm --filter @{{PROJECT_NAME}}/client start",
+    "test": "pnpm -r test",
+    "// {{IDENTITY_SCRIPTS}}": ""
+  }
+}

package/templates/base/packages/chain-config/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@{{PROJECT_NAME}}/chain-config",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "viem": "^2.21.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0"
+  }
+}

package/templates/base/packages/chain-config/src/chains.ts

@@ -0,0 +1,32 @@
+import { defineChain } from 'viem'
+
+export const confluxESpace = defineChain({
+  id: 1030,
+  name: 'Conflux eSpace',
+  nativeCurrency: { name: 'CFX', symbol: 'CFX', decimals: 18 },
+  rpcUrls: {
+    default: { http: ['https://evm.confluxrpc.com'] },
+  },
+  blockExplorers: {
+    default: {
+      name: 'ConfluxScan',
+      url: 'https://evm.confluxscan.io',
+    },
+  },
+})
+
+export const confluxESpaceTestnet = defineChain({
+  id: 71,
+  name: 'Conflux eSpace Testnet',
+  nativeCurrency: { name: 'CFX', symbol: 'CFX', decimals: 18 },
+  rpcUrls: {
+    default: { http: ['https://evmtestnet.confluxrpc.com'] },
+  },
+  blockExplorers: {
+    default: {
+      name: 'ConfluxScan Testnet',
+      url: 'https://evmtestnet.confluxscan.io',
+    },
+  },
+  testnet: true,
+})

package/templates/base/packages/chain-config/src/constants.ts

@@ -0,0 +1,24 @@
+import type { ChainConfig, TokenConfig } from './types.js'
+
+export const USDT0_MAINNET: TokenConfig = {
+  address: '0xaf37E8B6C9ED7f6318979f56Fc287d76c30847ff',
+  decimals: 6,
+  eip712: {
+    name: 'USDT0',
+    version: '1',
+  },
+} as const
+
+export const CONFLUX_ESPACE_MAINNET: ChainConfig = {
+  caip2Id: 'eip155:1030',
+  chainId: 1030,
+  rpcUrl: 'https://evm.confluxrpc.com',
+  token: USDT0_MAINNET,
+} as const
+
+export const CONFLUX_ESPACE_TESTNET: ChainConfig = {
+  caip2Id: 'eip155:71',
+  chainId: 71,
+  rpcUrl: 'https://evmtestnet.confluxrpc.com',
+  token: USDT0_MAINNET,
+} as const

package/templates/base/packages/chain-config/src/index.ts

@@ -0,0 +1,3 @@
+export { confluxESpace, confluxESpaceTestnet } from './chains.js'
+export { CONFLUX_ESPACE_MAINNET, CONFLUX_ESPACE_TESTNET, USDT0_MAINNET } from './constants.js'
+export type { Caip2Network, ChainConfig, TokenConfig } from './types.js'