# Solidity Compiler x402 Integration
> Browser Solidity compiler IDE - smart contract development, testing, deploy.
## Overview
**Repository:** [nirholas/solidity-compiler](https://github.com/nirholas/solidity-compiler)
**MCP Registry:** `io.github.nirholas/solidity-compiler`
**x402 Use Case:** Premium compilation, optimization, deployment services
## Installation
```bash
npm install @nirholas/x402-ecosystem @nirholas/solidity-compiler
```
## Integration Pattern
```typescript
import { PaywallBuilder, PricingStrategy } from '@nirholas/x402-ecosystem/premium';
import { SolidityCompiler } from '@nirholas/solidity-compiler';
// Compilation pricing
const compilerPricing = PricingStrategy.resourceBased({
'compile-basic': 0, // Free: basic compilation
'compile-optimized': 0.01, // $0.01: optimizer enabled
'compile-max-opt': 0.05, // $0.05: max optimization (200+ runs)
'verify-source': 0.02, // $0.02: Etherscan verification
'deploy-testnet': 0, // Free: testnet deployment
'deploy-mainnet': 0.10, // $0.10: mainnet deployment assist
'gas-estimation': 0.005, // $0.005: detailed gas analysis
'security-scan': 0.25, // $0.25: security vulnerability scan
'audit-report': 5.00 // $5.00: basic audit report
});
const compiler = new PaywallBuilder()
.service('solidity-compiler')
.pricing(compilerPricing)
.build();
```
## Compilation Tiers
```typescript
// Optimization levels
const optimizationLevels = {
none: { runs: 0, cost: 0 },
basic: { runs: 200, cost: 0.01 },
standard: { runs: 1000, cost: 0.02 },
maximum: { runs: 10000, cost: 0.05 }
};
// Compile with optimization
async function compileContract(
source: string,
settings: CompileSettings = {}
) {
const optimization = settings.optimization || 'none';
const config = optimizationLevels[optimization];
if (config.cost > 0) {
await compiler.charge(config.cost, {
type: 'compilation',
optimization,
runs: config.runs
});
}
return SolidityCompiler.compile(source, {
optimizer: {
enabled: config.runs > 0,
runs: config.runs
},
evmVersion: settings.evmVersion || 'paris'
});
}
```
## Source Verification
```typescript
// Premium Etherscan verification
async function verifyOnEtherscan(
address: string,
source: string,
constructorArgs: any[],
chain: 'ethereum' | 'arbitrum' | 'base' | 'polygon'
) {
await compiler.charge(0.02, {
type: 'verify-source',
chain,
address
});
return SolidityCompiler.verify({
address,
source,
constructorArgs,
chain,
compilerVersion: 'v0.8.24',
optimization: true,
runs: 200
});
}
```
## Security Scanning
```typescript
import { PayableAgent } from '@nirholas/x402-ecosystem/agent';
const agent = new PayableAgent({
wallet: agentWallet,
approvedServices: ['solidity-compiler'],
dailyLimit: 20
});
// Premium security scan
async function securityScan(source: string) {
await agent.pay({
service: 'solidity-compiler',
amount: 0.25,
description: 'Security vulnerability scan'
});
return SolidityCompiler.securityScan(source, {
checks: [
'reentrancy',
'overflow',
'access-control',
'oracle-manipulation',
'front-running',
'dos-vectors',
'unchecked-return'
]
});
}
// Basic audit report
async function generateAuditReport(source: string) {
await agent.pay({
service: 'solidity-compiler',
amount: 5.00,
description: 'Generate basic audit report'
});
const scan = await SolidityCompiler.securityScan(source);
const gasAnalysis = await SolidityCompiler.analyzeGas(source);
return SolidityCompiler.generateReport({
source,
securityFindings: scan,
gasAnalysis,
recommendations: true,
format: 'pdf'
});
}
```
## Gas Analysis
```typescript
// Premium gas estimation
async function analyzeGas(source: string) {
await compiler.charge(0.005, { type: 'gas-estimation' });
const compiled = await SolidityCompiler.compile(source);
return SolidityCompiler.analyzeGas(compiled, {
functions: true, // Per-function gas costs
deployment: true, // Deployment cost
optimization: true, // Optimization suggestions
comparison: true // Before/after optimization
});
}
```
## Deployment Assist
```typescript
// Premium mainnet deployment assistance
async function deployAssist(
bytecode: string,
abi: any[],
constructorArgs: any[],
chain: string
) {
const isMainnet = !chain.includes('testnet') && !chain.includes('sepolia');
if (isMainnet) {
await compiler.charge(0.10, {
type: 'deploy-mainnet',
chain
});
}
return SolidityCompiler.prepareDeployment({
bytecode,
abi,
constructorArgs,
chain,
// Returns: encoded data, gas estimate, recommended gas price
});
}
```
## Feature Matrix
| Feature | Free | Premium |
|---------|------|---------|
| Basic compilation | ✅ | ✅ |
| Testnet deployment | ✅ | ✅ |
| Optimized compile | ❌ | $0.01-0.05 |
| Source verification | ❌ | $0.02 |
| Gas analysis | ❌ | $0.005 |
| Security scan | ❌ | $0.25 |
| Mainnet assist | ❌ | $0.10 |
| Audit report | ❌ | $5.00 |
## Compiler Versions
```typescript
// Supported Solidity versions
const supportedVersions = [
'0.8.24', '0.8.23', '0.8.22', '0.8.21', '0.8.20',
'0.8.19', '0.8.18', '0.8.17', '0.8.0',
'0.7.6', '0.6.12', '0.5.17', '0.4.26'
];
```
## Revenue Model
```typescript
const revenueSplit = {
developer: 0.70, // Solidity Compiler maintainer
ecosystem: 0.20, // Universal Crypto MCP
infrastructure: 0.10 // x402 + compute costs
};
```
## MCP Tool Registration
```typescript
server.tool('compile_solidity', {
description: 'Compile Solidity smart contract with optional optimization',
inputSchema: z.object({
source: z.string(),
optimization: z.enum(['none', 'basic', 'standard', 'maximum']).default('none'),
evmVersion: z.string().optional()
}),
handler: async (params) => {
return compileContract(params.source, {
optimization: params.optimization,
evmVersion: params.evmVersion
});
}
});
server.tool('scan_contract_security', {
description: 'Scan Solidity contract for security vulnerabilities (premium)',
inputSchema: z.object({
source: z.string(),
generateReport: z.boolean().default(false)
}),
handler: async (params) => {
if (params.generateReport) {
return generateAuditReport(params.source);
}
return securityScan(params.source);
}
});
```
