agent-manifest 3.2.0

package/dist/parser/auth-detector.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthDetector = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const AUTH_SIGNALS = [
+    // Farcaster frame auth
+    { pattern: 'verifyFrameSignature', type: 'farcaster-frame', priority: 100 },
+    { pattern: '@farcaster/frame-node', type: 'farcaster-frame', priority: 100 },
+    { pattern: 'validateFrameMessage', type: 'farcaster-frame', priority: 100 },
+    { pattern: 'frameActionPayload', type: 'farcaster-frame', priority: 100 },
+    // OAuth2 / NextAuth / Auth.js
+    { pattern: 'NextAuth', type: 'oauth2', priority: 90 },
+    { pattern: 'next-auth', type: 'oauth2', priority: 90 },
+    { pattern: 'getServerSession', type: 'oauth2', priority: 85 },
+    { pattern: 'auth()', type: 'oauth2', priority: 85 },
+    { pattern: 'OAuthProvider', type: 'oauth2', priority: 80 },
+    { pattern: 'oauth2', type: 'oauth2', priority: 80 },
+    { pattern: 'access_token', type: 'oauth2', priority: 75 },
+    { pattern: 'refresh_token', type: 'oauth2', priority: 75 },
+    { pattern: 'clerkMiddleware', type: 'bearer', scheme: 'Bearer', priority: 88 },
+    { pattern: 'currentUser', type: 'bearer', scheme: 'Bearer', priority: 70 },
+    // JWT / Bearer
+    { pattern: 'jwt.verify', type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 70 },
+    { pattern: 'jsonwebtoken', type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 70 },
+    { pattern: 'jose', type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 65 },
+    { pattern: "split('Bearer ')", type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 70 },
+    { pattern: 'authorization.split', type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 70 },
+    { pattern: "headers.get('authorization')", type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 65 },
+    { pattern: "req.headers.authorization", type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 65 },
+    // API key
+    { pattern: "'x-api-key'", type: 'api-key', header: 'X-API-Key', priority: 60 },
+    { pattern: '"x-api-key"', type: 'api-key', header: 'X-API-Key', priority: 60 },
+    { pattern: 'X-API-Key', type: 'api-key', header: 'X-API-Key', priority: 60 },
+    { pattern: 'api_key', type: 'api-key', queryParam: 'api_key', priority: 55 },
+    { pattern: 'apiKey', type: 'api-key', queryParam: 'apiKey', priority: 50 },
+    // Basic auth
+    { pattern: "'Basic '", type: 'basic', header: 'Authorization', scheme: 'Basic', priority: 40 },
+    { pattern: '"Basic "', type: 'basic', header: 'Authorization', scheme: 'Basic', priority: 40 },
+    { pattern: 'btoa(', type: 'basic', header: 'Authorization', scheme: 'Basic', priority: 35 },
+    // Session / cookie
+    { pattern: 'getSession(', type: 'cookie', priority: 30 },
+    { pattern: 'req.session', type: 'cookie', priority: 30 },
+    { pattern: 'iron-session', type: 'cookie', priority: 30 },
+    { pattern: 'cookies()', type: 'cookie', priority: 25 },
+    { pattern: 'req.cookies', type: 'cookie', priority: 25 },
+];
+class AuthDetector {
+    best = null;
+    scanContent(content) {
+        for (const signal of AUTH_SIGNALS) {
+            if (content.includes(signal.pattern)) {
+                if (!this.best || signal.priority > this.best.priority) {
+                    this.best = signal;
+                }
+            }
+        }
+    }
+    /** Read package.json to detect auth libraries in dependencies */
+    readPackageJson(projectPath) {
+        const pkgPath = path.join(projectPath, 'package.json');
+        if (!fs.existsSync(pkgPath))
+            return;
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (deps['next-auth'] || deps['@auth/core'])
+                this.applySignal({ pattern: 'next-auth', type: 'oauth2', priority: 90 });
+            if (deps['@clerk/nextjs'] || deps['@clerk/clerk-sdk-node'])
+                this.applySignal({ pattern: 'clerk', type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 88 });
+            if (deps['jsonwebtoken'] || deps['jose'])
+                this.applySignal({ pattern: 'jwt', type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 70 });
+            if (deps['iron-session'])
+                this.applySignal({ pattern: 'iron-session', type: 'cookie', priority: 30 });
+            if (deps['@farcaster/frame-node'])
+                this.applySignal({ pattern: 'farcaster-frame', type: 'farcaster-frame', priority: 100 });
+        }
+        catch { /* ignore */ }
+    }
+    applySignal(signal) {
+        if (!this.best || signal.priority > this.best.priority) {
+            this.best = signal;
+        }
+    }
+    getAuth() {
+        if (!this.best)
+            return { type: 'none' };
+        const config = { type: this.best.type };
+        if (this.best.header)
+            config.header = this.best.header;
+        if (this.best.scheme)
+            config.scheme = this.best.scheme;
+        if (this.best.queryParam)
+            config.queryParam = this.best.queryParam;
+        return config;
+    }
+}
+exports.AuthDetector = AuthDetector;

package/dist/parser/capability-detector.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Detects app capabilities by scanning file content for known SDK/library patterns.
+ *
+ * Capabilities are generic (not Farcaster-specific) so agent.json works for any app.
+ * Farcaster-specific signals are still included but map to generic capability names
+ * where possible, plus a 'farcaster' capability for Farcaster-specific features.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityDetector = void 0;
+const CAPABILITY_SIGNALS = [
+    // ── Payments ────────────────────────────────────────────────────────────
+    { pattern: 'stripe', capability: 'payments' },
+    { pattern: 'Stripe(', capability: 'payments' },
+    { pattern: 'loadStripe', capability: 'payments' },
+    { pattern: 'paymentIntent', capability: 'payments' },
+    { pattern: 'checkout.sessions', capability: 'payments' },
+    // ── Wallet / onchain ────────────────────────────────────────────────────
+    { pattern: 'sdk.wallet', capability: 'wallet' },
+    { pattern: 'ethProvider', capability: 'wallet' },
+    { pattern: 'useWalletClient', capability: 'wallet' },
+    { pattern: 'useConnect', capability: 'wallet' },
+    { pattern: 'useAccount', capability: 'wallet' },
+    { pattern: 'useWriteContract', capability: 'wallet' },
+    { pattern: 'writeContract', capability: 'wallet' },
+    { pattern: 'ethers.provider', capability: 'wallet' },
+    { pattern: 'web3.eth', capability: 'wallet' },
+    // ── Notifications ───────────────────────────────────────────────────────
+    { pattern: 'sendNotification', capability: 'notifications' },
+    { pattern: 'useNotifications', capability: 'notifications' },
+    { pattern: 'addFrameNotification', capability: 'notifications' },
+    { pattern: 'sdk.actions.addFrameNotification', capability: 'notifications' },
+    { pattern: 'webpush', capability: 'notifications' },
+    { pattern: 'PushSubscription', capability: 'notifications' },
+    { pattern: 'Notification.requestPermission', capability: 'notifications' },
+    { pattern: 'sendEmail', capability: 'notifications' },
+    { pattern: 'resend.emails', capability: 'notifications' },
+    { pattern: 'nodemailer', capability: 'notifications' },
+    { pattern: 'twilio', capability: 'notifications' },
+    // ── File / media uploads ────────────────────────────────────────────────
+    { pattern: 'put(', capability: 'storage' },
+    { pattern: 'upload(', capability: 'storage' },
+    { pattern: 'multer', capability: 'storage' },
+    { pattern: 'formData()', capability: 'storage' },
+    { pattern: 'vercel/blob', capability: 'storage' },
+    { pattern: 'sdk.actions.openCamera', capability: 'storage' },
+    { pattern: 's3.upload', capability: 'storage' },
+    { pattern: 'cloudinary', capability: 'storage' },
+    // ── Social (generic) ────────────────────────────────────────────────────
+    { pattern: 'sdk.actions.composeCast', capability: 'social' },
+    { pattern: 'openCompose', capability: 'social' },
+    { pattern: 'composeCast', capability: 'social' },
+    // ── Location / geo ──────────────────────────────────────────────────────
+    { pattern: 'sdk.context.location', capability: 'location' },
+    { pattern: 'sdk.location', capability: 'location' },
+    { pattern: 'geolocation', capability: 'location' },
+    { pattern: 'navigator.geolocation', capability: 'location' },
+    // ── AI / LLM ────────────────────────────────────────────────────────────
+    { pattern: 'openai', capability: 'ai' },
+    { pattern: 'anthropic', capability: 'ai' },
+    { pattern: 'streamText(', capability: 'ai' },
+    { pattern: 'generateText(', capability: 'ai' },
+    { pattern: 'useChat(', capability: 'ai' },
+    // ── Farcaster-specific (preserved for Farcaster mini-apps) ───────────────
+    { pattern: 'sdk.actions.addFrame', capability: 'farcaster' },
+    { pattern: 'sdk.actions.ready', capability: 'farcaster' },
+    { pattern: 'sdk.haptics', capability: 'farcaster' },
+    { pattern: 'sdk.actions.openUrl', capability: 'navigation' },
+    { pattern: 'requestContact', capability: 'contacts' },
+    // ── Database / data ─────────────────────────────────────────────────────
+    { pattern: 'prisma.', capability: 'database' },
+    { pattern: 'supabase.', capability: 'database' },
+    { pattern: 'drizzle(', capability: 'database' },
+    // ── Real-time ────────────────────────────────────────────────────────────
+    { pattern: 'socket.io', capability: 'realtime' },
+    { pattern: 'new WebSocket', capability: 'realtime' },
+    { pattern: 'pusher', capability: 'realtime' },
+    { pattern: 'ably', capability: 'realtime' },
+];
+class CapabilityDetector {
+    detected = new Set();
+    /**
+     * Scan a file's raw content for capability signal strings.
+     * This is intentionally fast (string search, no AST) since it runs over every file.
+     */
+    scanContent(content) {
+        for (const { pattern, capability } of CAPABILITY_SIGNALS) {
+            if (content.includes(pattern)) {
+                this.detected.add(capability);
+            }
+        }
+    }
+    /**
+     * Read capabilities declared in farcaster.json.
+     * Accepts the parsed frame object.
+     */
+    readManifest(frame) {
+        // Explicit capability declarations
+        const declared = frame.capabilities ?? frame.requiredCapabilities;
+        if (Array.isArray(declared)) {
+            for (const cap of declared) {
+                if (typeof cap === 'string')
+                    this.detected.add(cap);
+            }
+        }
+        // Infer wallet capability if a default chain or web3 config is present
+        if (frame.chainId || frame.defaultChain) {
+            this.detected.add('wallet');
+        }
+    }
+    getCapabilities() {
+        return Array.from(this.detected).sort();
+    }
+}
+exports.CapabilityDetector = CapabilityDetector;

package/dist/parser/contract-parser.js

@@ -0,0 +1,347 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractParser = void 0;
+const ts_morph_1 = require("ts-morph");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const intent_classifier_1 = require("./intent-classifier");
+/** viem/wagmi chain variable names → EIP-155 chain IDs */
+const KNOWN_CHAINS = {
+    mainnet: 1,
+    goerli: 5,
+    sepolia: 11155111,
+    optimism: 10,
+    optimismGoerli: 420,
+    optimismSepolia: 11155420,
+    base: 8453,
+    baseSepolia: 84532,
+    arbitrum: 42161,
+    arbitrumSepolia: 421614,
+    polygon: 137,
+    polygonMumbai: 80001,
+    polygonAmoy: 80002,
+    zora: 7777777,
+    zoraSepolia: 999999999,
+    avalanche: 43114,
+    bsc: 56,
+    gnosis: 100,
+    celo: 42220,
+    linea: 59144,
+    scroll: 534352,
+    mode: 34443,
+    blast: 81457,
+    mantle: 5000,
+    fraxtal: 252,
+};
+class ContractParser {
+    projectPath;
+    constructor(projectPath) {
+        this.projectPath = projectPath;
+    }
+    async parseAbiFile(filePath) {
+        try {
+            const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            if (!Array.isArray(content))
+                return [];
+            const actions = [];
+            for (const item of content) {
+                if (item.type !== 'function')
+                    continue;
+                const isReadOnly = item.stateMutability === 'view' || item.stateMutability === 'pure';
+                const safety = (0, intent_classifier_1.classifySafety)({ name: item.name, isReadOnly, type: 'contract' });
+                actions.push({
+                    name: item.name,
+                    description: isReadOnly
+                        ? `Read contract: ${item.name}`
+                        : `Write contract: ${item.name}`,
+                    intent: (0, intent_classifier_1.inferIntent)(item.name),
+                    type: 'contract',
+                    location: `./${path.relative(this.projectPath, filePath)}`,
+                    abiFunction: item.name,
+                    isReadOnly,
+                    safety,
+                    agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                    requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety, isReadOnly, type: 'contract' }),
+                    inputs: this.mapAbiInputs(item.inputs ?? []),
+                    outputs: {
+                        type: this.mapAbiOutputs(item.outputs ?? []),
+                        description: '',
+                    },
+                });
+            }
+            return actions;
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Detect wagmi contract interactions (useWriteContract, writeContract, etc.)
+     * and cross-reference imported ABI files to extract real parameter types.
+     */
+    async detectHooks(sourceFile) {
+        const actions = [];
+        const abiMap = this.buildAbiImportMap(sourceFile);
+        sourceFile.forEachDescendant(node => {
+            if (!ts_morph_1.Node.isObjectLiteralExpression(node))
+                return;
+            const props = node.getProperties();
+            // Collect relevant property assignments by key name
+            let abiVarName = null;
+            let functionName = null;
+            let chainId;
+            let contractAddress;
+            for (const prop of props) {
+                if (!ts_morph_1.Node.isPropertyAssignment(prop))
+                    continue;
+                const key = prop.getName();
+                const init = prop.getInitializer();
+                if (!init)
+                    continue;
+                if (key === 'abi') {
+                    abiVarName = init.getText().trim();
+                }
+                if (key === 'functionName' && ts_morph_1.Node.isStringLiteral(init)) {
+                    functionName = init.getLiteralValue();
+                }
+                // Explicit numeric chainId: { chainId: 8453 }
+                if (key === 'chainId' && ts_morph_1.Node.isNumericLiteral(init)) {
+                    chainId = Number(init.getLiteralValue());
+                }
+                // Chain object reference: { chain: base } → resolve known chain names
+                if (key === 'chain') {
+                    chainId = KNOWN_CHAINS[init.getText().trim()] ?? chainId;
+                }
+                // Contract address: literal or env var reference
+                if (key === 'address') {
+                    contractAddress = resolveAddressNode(init);
+                }
+            }
+            if (!abiVarName || !functionName)
+                return;
+            // Cross-reference against imported ABI for real parameter types
+            let parameters = {};
+            const abi = abiMap.get(abiVarName);
+            if (abi) {
+                const abiFunc = abi.find((item) => item.type === 'function' && item.name === functionName);
+                if (abiFunc) {
+                    parameters = this.mapAbiInputs(abiFunc.inputs ?? []);
+                }
+            }
+            const safety = (0, intent_classifier_1.classifySafety)({ name: functionName, isReadOnly: false, type: 'contract' });
+            actions.push({
+                name: functionName,
+                description: `Contract interaction: ${functionName}`,
+                intent: (0, intent_classifier_1.inferIntent)(functionName),
+                type: 'contract',
+                location: sourceFile.getFilePath(),
+                abiFunction: functionName,
+                ...(chainId !== undefined ? { chainId } : {}),
+                ...(contractAddress !== undefined ? { contractAddress } : {}),
+                safety,
+                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety, isReadOnly: false, type: 'contract' }),
+                inputs: parameters,
+                outputs: { type: 'any' },
+            });
+        });
+        return actions;
+    }
+    // ─── Private helpers ─────────────────────────────────────────────────────
+    /**
+     * Resolve relative imports that point to JSON ABI files.
+     * Returns a map of imported identifier -> ABI array.
+     * Also resolves TypeScript path aliases (e.g. @/abis/GameABI).
+     */
+    buildAbiImportMap(sourceFile) {
+        const map = new Map();
+        const sourceDir = path.dirname(sourceFile.getFilePath());
+        const aliasMap = this.loadTsAliases();
+        for (const importDecl of sourceFile.getImportDeclarations()) {
+            const spec = importDecl.getModuleSpecifierValue();
+            // Resolve the specifier to a filesystem path
+            let resolvedSpec = null;
+            if (spec.startsWith('.')) {
+                resolvedSpec = path.resolve(sourceDir, spec);
+            }
+            else {
+                // Try TS path aliases
+                const aliasResolved = this.resolveAlias(spec, aliasMap);
+                if (aliasResolved)
+                    resolvedSpec = aliasResolved;
+            }
+            if (!resolvedSpec)
+                continue;
+            const candidates = [
+                resolvedSpec,
+                `${resolvedSpec}.json`,
+            ];
+            for (const candidate of candidates) {
+                if (!fs.existsSync(candidate))
+                    continue;
+                try {
+                    const parsed = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+                    if (!Array.isArray(parsed))
+                        break;
+                    for (const namedImport of importDecl.getNamedImports()) {
+                        map.set(namedImport.getName(), parsed);
+                    }
+                    const defaultImport = importDecl.getDefaultImport();
+                    if (defaultImport) {
+                        map.set(defaultImport.getText(), parsed);
+                    }
+                    break;
+                }
+                catch { /* ignore */ }
+            }
+        }
+        return map;
+    }
+    /**
+     * Read tsconfig.json compilerOptions.paths and baseUrl.
+     * Returns a map of alias prefix → array of filesystem root paths.
+     * e.g. { "@/*": ["/project/src/*"] }
+     */
+    loadTsAliases() {
+        const aliases = new Map();
+        const tsconfigPath = path.join(this.projectPath, 'tsconfig.json');
+        if (!fs.existsSync(tsconfigPath))
+            return aliases;
+        try {
+            // Strip JSON comments before parsing (tsconfig allows them)
+            const raw = fs.readFileSync(tsconfigPath, 'utf8')
+                .replace(/\/\/[^\n]*/g, '')
+                .replace(/\/\*[\s\S]*?\*\//g, '');
+            const tsconfig = JSON.parse(raw);
+            const opts = tsconfig.compilerOptions ?? {};
+            const baseUrl = opts.baseUrl
+                ? path.resolve(this.projectPath, opts.baseUrl)
+                : this.projectPath;
+            for (const [alias, targets] of Object.entries(opts.paths ?? {})) {
+                const resolved = targets.map(t => path.resolve(baseUrl, t));
+                aliases.set(alias, resolved);
+            }
+        }
+        catch { /* ignore malformed tsconfig */ }
+        return aliases;
+    }
+    /**
+     * Resolve a module specifier against tsconfig path aliases.
+     * e.g. "@/abis/GameABI" → "/project/src/abis/GameABI"
+     */
+    resolveAlias(spec, aliases) {
+        for (const [pattern, targets] of aliases) {
+            if (pattern.endsWith('/*')) {
+                const prefix = pattern.slice(0, -2); // "@/"
+                if (!spec.startsWith(prefix))
+                    continue;
+                const rest = spec.slice(prefix.length); // "abis/GameABI"
+                for (const target of targets) {
+                    const resolvedTarget = target.endsWith('/*')
+                        ? path.join(target.slice(0, -2), rest)
+                        : path.join(target, rest);
+                    if (fs.existsSync(resolvedTarget) || fs.existsSync(`${resolvedTarget}.json`)) {
+                        return resolvedTarget;
+                    }
+                }
+            }
+            else if (spec === pattern) {
+                // Exact match
+                return targets[0] ?? null;
+            }
+        }
+        return null;
+    }
+    mapAbiInputs(inputs) {
+        const props = {};
+        for (const input of inputs) {
+            props[input.name || 'arg'] = {
+                type: this.mapSolidityType(input.type),
+                description: `Solidity type: ${input.type}`,
+                required: true,
+            };
+        }
+        return props;
+    }
+    mapAbiOutputs(outputs) {
+        if (!outputs.length)
+            return 'void';
+        if (outputs.length === 1)
+            return this.mapSolidityType(outputs[0].type);
+        return 'object';
+    }
+    mapSolidityType(type) {
+        if (type.startsWith('uint') || type.startsWith('int'))
+            return 'number';
+        if (type === 'bool')
+            return 'boolean';
+        if (type === 'address')
+            return 'string';
+        if (type.startsWith('bytes'))
+            return 'string';
+        if (type.endsWith('[]'))
+            return 'array';
+        return 'string';
+    }
+}
+exports.ContractParser = ContractParser;
+// ─── Module-level helpers ─────────────────────────────────────────────────────
+/**
+ * Resolve a wagmi `address` node to either:
+ *   - a literal `0x...` string (safe — on-chain public data)
+ *   - `{ $env: "VAR_NAME" }` when referencing process.env.* (never leak actual value)
+ *   - undefined if not resolvable
+ */
+function resolveAddressNode(node) {
+    // Literal string: address: '0xABC...'
+    if (ts_morph_1.Node.isStringLiteral(node)) {
+        const val = node.getLiteralValue();
+        if (/^0x[0-9a-fA-F]{40}$/i.test(val))
+            return val;
+        return undefined;
+    }
+    // Type assertion: address: '0xABC...' as `0x${string}`
+    if (ts_morph_1.Node.isAsExpression(node)) {
+        return resolveAddressNode(node.getExpression());
+    }
+    // process.env.NEXT_PUBLIC_CONTRACT_ADDRESS → { $env: "NEXT_PUBLIC_CONTRACT_ADDRESS" }
+    // Also handles: process.env.NEXT_PUBLIC_CONTRACT_ADDRESS as `0x${string}`
+    const text = node.getText().trim();
+    const envMatch = text.match(/process\.env\.([A-Z0-9_]+)/);
+    if (envMatch)
+        return { $env: envMatch[1] };
+    return undefined;
+}