@mapprotocol/common-contracts 0.2.0 → 0.3.0

package/utils/index.ts

@@ -1,25 +1,42 @@
+/**
+ * @mapprotocol/common-contracts/utils
+ *
+ * Shared TypeScript utilities for MAP Protocol contract operations.
+ *
+ * Quick start:
+ *   const deployer = createDeployer(hre, { autoVerify: true });
+ *   await deployer.deploy("MyContract", [arg1], "optional_salt");
+ *   await deployer.deployProxy("MyContract", [initArg], "optional_salt");
+ *   await deployer.upgrade("MyContract", proxyAddr);
+ */
+
+// Unified deployer — recommended entry point for deploy/upgrade/verify
+export {
+    createDeployer,
+    type Deployer,
+    type DeployResult,
+    type DeployProxyResult,
+    type DeployerOptions
+} from "./deployer";
+
+// Deploy record — deploy.json address management
 export {
-    resolveDeploymentEnv,
+    resolveDeploymentPath,
     getDeploymentByKey,
     hasDeployment,
     saveDeployment,
+    type DeploymentPath,
     type DeploymentOptions
-} from "./deployment";
+} from "./deployRecord";
 
-export {
-    tronDeploy,
-    getTronContract,
-    getTronDeployer,
-    tronFromHex,
-    tronToHex,
-    isTronNetwork,
-    createTronWeb,
-    type TronConfig
-} from "./tronHelper";
+// Contract verification
+export { verify, type VerifyOptions } from "./verifier";
 
-export {
-    addressToHex,
-    isBase58,
-    isTronAddress,
-    isSolanaChain
-} from "./addressCodec";
+// Code hash for CREATE2 address prediction
+export { getCodeHash, getProxyCodeHash, getCustomProxyCodeHash } from "./codeHash";
+
+// Address encoding
+export { addressToHex, isBase58, isTronAddress, isSolanaChain } from "./addressCodec";
+
+// Tron utilities
+export { TronClient, tronFromHex, tronToHex, isTronNetwork, sendAndWait, waitForTx, type TronAddress } from "./tronHelper";

package/utils/tronHelper.ts

@@ -4,77 +4,359 @@ let TronWeb = require("tronweb");
 // Pure address conversion — no RPC, no private key needed
 // ============================================================
 
+/** Convert hex address to Tron base58 format. Returns as-is if already base58. */
 export function tronFromHex(hex: string): string {
     if (hex.startsWith("T") && hex.length === 34) return hex;
     return TronWeb.address.fromHex(hex);
 }
 
+/** Convert Tron base58 address to 0x-prefixed hex. Returns as-is if already hex. */
 export function tronToHex(addr: string): string {
     if (addr.startsWith("0x") && addr.length === 42) return addr;
     return TronWeb.address.toHex(addr).replace(/^(41)/, "0x");
 }
 
-export function isTronNetwork(network: string): boolean {
-    return network === "Tron" || network === "tron_test" || network === "Tron_test";
+// Tron chainIds: mainnet 728126428, nile testnet 3448148188
+const TRON_CHAIN_IDS = [728126428, 3448148188];
+
+/** Check if a network name or chainId belongs to Tron (case-insensitive). */
+export function isTronNetwork(networkOrChainId: string | number): boolean {
+    if (typeof networkOrChainId === "number") {
+        return TRON_CHAIN_IDS.includes(networkOrChainId);
+    }
+    return networkOrChainId.toLowerCase().startsWith("tron");
+}
+
+export interface TronAddress {
+    hex: string;    // 0x-prefixed address
+    base58: string; // T-prefixed address
 }
 
 // ============================================================
-// TronWeb instance creation
+// TronClient
 // ============================================================
 
-export interface TronConfig {
-    rpcUrl: string;
-    privateKey?: string; // optional — omit for read-only operations
-}
+/**
+ * TronClient — encapsulates tronWeb instance, provides high-level contract operations.
+ *
+ * Usage:
+ *   // From hardhat runtime (recommended in tasks)
+ *   let client = TronClient.fromHre(hre);
+ *
+ *   // Manual — with rpc and private key
+ *   let client = new TronClient("https://api.trongrid.io", "your_private_key");
+ *
+ *   // Read-only — no private key
+ *   let client = new TronClient("https://api.trongrid.io");
+ *
+ *   // Contract interaction
+ *   let gw = await client.getContract(artifacts, "Gateway", addr);
+ *   let wtoken = await gw.wToken().call();                      // read
+ *   await gw.setWtoken(client.toHex(wtoken)).sendAndWait();     // write + wait
+ *
+ *   // Deploy
+ *   let { hex, base58 } = await client.deploy(artifacts, "Gateway");
+ *   let { proxy, implementation } = await client.deployProxy(artifacts, "Gateway", [admin]);
+ *
+ *   // Upgrade
+ *   await client.upgradeProxy(artifacts, "Gateway", proxyAddr);
+ */
+export class TronClient {
+    private tronWeb: any;
+    private connected: boolean = false;
+
+    /**
+     * Create a TronClient with explicit rpcUrl.
+     * @param rpcUrl - Tron full host URL (e.g. "https://api.trongrid.io")
+     * @param privateKey - optional, omit for read-only operations
+     */
+    constructor(rpcUrl: string, privateKey?: string) {
+        const opts: any = { fullHost: rpcUrl };
+        if (privateKey) {
+            // TronWeb doesn't accept 0x prefix on private keys
+            opts.privateKey = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
+        }
+        this.tronWeb = new TronWeb(opts);
+    }
+
+    /**
+     * Create TronClient from hardhat runtime environment.
+     * Reads rpcUrl and privateKey from hre.network.config. Verifies RPC connectivity.
+     */
+    static fromHre(hre: any): TronClient {
+        const config = hre.network.config;
+        let rpcUrl: string = config.url;
+        let privateKey = Array.isArray(config.accounts) ? config.accounts[0] : undefined;
+        if (!rpcUrl) throw new Error(`no rpc url configured for network ${hre.network.name}`);
+        // Hardhat config uses JSON-RPC path (e.g. /jsonrpc), TronWeb needs base URL
+        rpcUrl = rpcUrl.replace(/\/(jsonrpc|wallet|solidity)\/?$/i, "");
+        // TronWeb doesn't accept 0x prefix on private keys
+        if (privateKey && privateKey.startsWith("0x")) {
+            privateKey = privateKey.slice(2);
+        }
+        return new TronClient(rpcUrl, privateKey);
+    }
+
+    /** Verify RPC is reachable. Uses getNowBlock which is widely supported. */
+    private async _checkConnection(): Promise<void> {
+        if (this.connected) return;
+        try {
+            // getNowBlock calls /wallet/getnowblock — more universally supported than getNodeInfo
+            await this.tronWeb.trx.getCurrentBlock();
+            this.connected = true;
+        } catch (e: any) {
+            const url = this.tronWeb.fullNode?.host || "unknown";
+            throw new Error(
+                `TronClient: cannot connect to ${url}. ` +
+                `Ensure the URL is a valid TronWeb full host (e.g. "https://api.trongrid.io") and is reachable. ` +
+                `Error: ${e.message || e}`
+            );
+        }
+    }
+
+    /** Lazy connection check — called before first contract operation. */
+    private async _ensureConnected(): Promise<void> {
+        if (!this.connected) await this._checkConnection();
+    }
+
+    /** Get the default operator address in base58 format. */
+    get defaultAddress(): string {
+        return this.tronWeb.defaultAddress.base58;
+    }
+
+    /** Convert Tron base58 address to 0x hex. */
+    toHex(addr: string): string {
+        return tronToHex(addr);
+    }
+
+    /** Convert 0x hex to Tron base58 address. */
+    fromHex(hex: string): string {
+        return tronFromHex(hex);
+    }
+
+    /**
+     * Get a contract instance. Write methods have .sendAndWait() attached.
+     * @param artifacts - hardhat artifacts (hre.artifacts)
+     * @param contractName - contract name (e.g. "Gateway")
+     * @param addr - contract address (base58 or hex)
+     */
+    async getContract(artifacts: any, contractName: string, addr: string): Promise<any> {
+        await this._ensureConnected();
+        console.log("operator address is:", this.defaultAddress);
+        const artifact = await artifacts.readArtifact(contractName);
+        const contract = await this.tronWeb.contract(artifact.abi, addr);
+        return this._wrapContract(contract);
+    }
+
+    /**
+     * Deploy contract. If salt is provided, uses CREATE2 factory.
+     * @param artifacts - hardhat artifacts
+     * @param contractName - contract name to deploy
+     * @param args - constructor arguments
+     * @param salt - optional CREATE2 salt for deterministic address
+     * @param feeLimit - Tron fee limit (default 15 TRX)
+     */
+    async deploy(
+        artifacts: any,
+        contractName: string,
+        args: any[] = [],
+        salt: string = "",
+        feeLimit: number = 15_000_000_000
+    ): Promise<TronAddress> {
+        await this._ensureConnected();
+        return tronDeploy(this.tronWeb, artifacts, contractName, args, salt, feeLimit);
+    }
+
+    /**
+     * Deploy implementation + ERC1967 proxy. If salt is provided, proxy uses factory.
+     * @param artifacts - hardhat artifacts
+     * @param contractName - implementation contract name
+     * @param initArgs - initialize() function arguments
+     * @param salt - optional CREATE2 salt for proxy
+     * @param feeLimit - Tron fee limit
+     */
+    async deployProxy(
+        artifacts: any,
+        contractName: string,
+        initArgs: any[] = [],
+        salt: string = "",
+        feeLimit: number = 15_000_000_000
+    ): Promise<{ proxy: TronAddress; implementation: TronAddress }> {
+        await this._ensureConnected();
+        return tronDeployProxy(this.tronWeb, artifacts, contractName, initArgs, salt, feeLimit);
+    }
+
+    /**
+     * Upgrade a UUPS proxy to a new implementation.
+     * @param artifacts - hardhat artifacts
+     * @param contractName - new implementation contract name
+     * @param proxyAddr - proxy address to upgrade
+     * @param feeLimit - Tron fee limit
+     */
+    async upgradeProxy(
+        artifacts: any,
+        contractName: string,
+        proxyAddr: string,
+        feeLimit: number = 15_000_000_000
+    ): Promise<TronAddress> {
+        await this._ensureConnected();
+        return tronUpgradeProxy(this.tronWeb, artifacts, contractName, proxyAddr, feeLimit);
+    }
+
+    /**
+     * Wait for a transaction to be confirmed on-chain.
+     * @param txId - transaction hash from .send()
+     */
+    async waitForTx(txId: string, retries: number = 20, interval: number = 3000): Promise<any> {
+        return waitForTx(this.tronWeb, txId, retries, interval);
+    }
+
+    /** Wrap contract methods — adds .sendAndWait() to write methods. */
+    private _wrapContract(contract: any): any {
+        const tronWeb = this.tronWeb;
+        return new Proxy(contract, {
+            get(target, prop) {
+                const original = target[prop];
+                if (typeof original !== "function") return original;
 
-export function createTronWeb(config: TronConfig) {
-    const opts: any = { fullHost: config.rpcUrl };
-    if (config.privateKey) {
-        opts.privateKey = config.privateKey;
+                return (...args: any[]) => {
+                    const methodCall = original.apply(target, args);
+                    if (methodCall && typeof methodCall.send === "function") {
+                        methodCall.sendAndWait = (opts?: Record<string, any>) =>
+                            sendAndWait(methodCall, tronWeb, opts);
+                    }
+                    return methodCall;
+                };
+            }
+        });
     }
-    return new TronWeb(opts);
 }
 
 // ============================================================
-// Contract interaction — requires tronWeb instance
+// Low-level functions (used internally by TronClient)
 // ============================================================
 
+/** @internal Deploy contract on Tron. If salt is provided, uses CREATE2 factory. */
 export async function tronDeploy(
     tronWeb: any,
     artifacts: any,
     contractName: string,
     args: any[] = [],
+    salt: string = "",
     feeLimit: number = 15_000_000_000
-): Promise<string> {
-    let c = await artifacts.readArtifact(contractName);
+): Promise<TronAddress> {
+    if (salt) {
+        const { tronDeployByFactory } = require("./factory");
+        const hex: string = await tronDeployByFactory(tronWeb, artifacts, contractName, salt, args, feeLimit);
+        return { hex, base58: tronFromHex(hex) };
+    }
+
+    const artifact = await artifacts.readArtifact(contractName);
     console.log("deploy address is:", tronWeb.defaultAddress.base58);
-    let instance = await tronWeb.contract().new({
-        abi: c.abi,
-        bytecode: c.bytecode,
+    const instance = await tronWeb.contract().new({
+        abi: artifact.abi,
+        bytecode: artifact.bytecode,
         feeLimit,
         callValue: 0,
         parameters: args,
     });
-    let hex = instance.address; // 41-prefixed hex
-    let base58 = tronWeb.address.fromHex(hex);
+    const rawAddress = instance.address; // 41-prefixed hex
+    const hex = rawAddress.replace(/^41/, "0x");
+    const base58 = tronWeb.address.fromHex(rawAddress);
     console.log(`${contractName} deployed: ${base58} (${hex})`);
-    return hex.replace(/^41/, "0x");
+    return { hex, base58 };
+}
+
+/** @internal Deploy implementation + ERC1967 proxy on Tron. */
+export async function tronDeployProxy(
+    tronWeb: any,
+    artifacts: any,
+    contractName: string,
+    initArgs: any[] = [],
+    salt: string = "",
+    feeLimit: number = 15_000_000_000
+): Promise<{ proxy: TronAddress; implementation: TronAddress }> {
+    const implementation = await tronDeploy(tronWeb, artifacts, contractName, [], "", feeLimit);
+    console.log(`${contractName} implementation: ${implementation.base58} (${implementation.hex})`);
+
+    // Wait for implementation to be fully confirmed before deploying proxy
+    if (salt) {
+        console.log("waiting for implementation to be indexed...");
+        await new Promise(r => setTimeout(r, 5000));
+    }
+
+    const artifact = await artifacts.readArtifact(contractName);
+    const iface = new (require("ethers").Interface)(artifact.abi);
+    const initData = iface.encodeFunctionData("initialize", initArgs);
+
+    const proxy = await tronDeploy(tronWeb, artifacts, "ERC1967Proxy", [implementation.hex, initData], salt, feeLimit);
+    console.log(`${contractName} proxy: ${proxy.base58} (${proxy.hex})`);
+
+    return { proxy, implementation };
 }
 
-export async function getTronContract(
+/** @internal Upgrade a UUPS proxy to a new implementation on Tron. */
+export async function tronUpgradeProxy(
     tronWeb: any,
     artifacts: any,
     contractName: string,
-    addr: string
+    proxyAddr: string,
+    feeLimit: number = 15_000_000_000
+): Promise<TronAddress> {
+    const impl = await tronDeploy(tronWeb, artifacts, contractName, [], "", feeLimit);
+    console.log(`${contractName} new implementation: ${impl.base58} (${impl.hex})`);
+
+    const artifact = await artifacts.readArtifact("BaseImplementation");
+    const proxyContract = await tronWeb.contract(artifact.abi, proxyAddr);
+    const oldImpl = await proxyContract.getImplementation().call();
+    console.log(`old implementation: ${tronFromHex(oldImpl)}`);
+
+    await sendAndWait(proxyContract.upgradeToAndCall(impl.hex, "0x"), tronWeb, { feeLimit });
+
+    const newImpl = await proxyContract.getImplementation().call();
+    console.log(`${contractName} upgraded: ${tronFromHex(oldImpl)} -> ${tronFromHex(newImpl)}`);
+    return impl;
+}
+
+/**
+ * Send a tron contract call and wait for on-chain confirmation.
+ * @param methodCall - tronweb contract method call (e.g. contract.setWtoken(addr))
+ * @param tronWeb - tronweb instance for querying tx status
+ * @param opts - send options (feeLimit, callValue, etc.)
+ */
+export async function sendAndWait(
+    methodCall: any,
+    tronWeb: any,
+    opts: Record<string, any> = {}
 ): Promise<any> {
-    console.log("operator address is:", tronWeb.defaultAddress.base58);
-    let C = await artifacts.readArtifact(contractName);
-    return tronWeb.contract(C.abi, addr);
+    const txId = await methodCall.send(opts);
+    return waitForTx(tronWeb, txId);
 }
 
-export function getTronDeployer(tronWeb: any, hex: boolean = false): string {
-    if (hex) {
-        return tronWeb.defaultAddress.hex.replace(/^(41)/, "0x");
+/**
+ * Wait for a Tron transaction to be confirmed on-chain.
+ * @param tronWeb - tronweb instance
+ * @param txId - transaction hash returned by .send()
+ * @param retries - max poll attempts (default 20)
+ * @param interval - poll interval in ms (default 3000)
+ */
+export async function waitForTx(
+    tronWeb: any,
+    txId: string,
+    retries: number = 20,
+    interval: number = 3000
+): Promise<any> {
+    console.log(`waiting for tx ${txId}...`);
+    for (let i = 0; i < retries; i++) {
+        const result = await tronWeb.trx.getTransactionInfo(txId);
+        if (result && result.id) {
+            if (result.receipt?.result === "SUCCESS") {
+                console.log(`tx confirmed in block ${result.blockNumber}`);
+                return result;
+            }
+            throw new Error(`tx failed: ${result.receipt?.result || "UNKNOWN"}`);
+        }
+        await new Promise(r => setTimeout(r, interval));
     }
-    return tronWeb.defaultAddress.base58;
+    throw new Error(`tx not confirmed after ${retries} retries: ${txId}`);
 }

package/utils/verifier.ts

@@ -0,0 +1,225 @@
+/**
+ * Contract verification — supports Etherscan, Blockscout (Mapo), and TronScan.
+ * Auto-routes based on network name.
+ */
+import { isTronNetwork, tronFromHex } from "./tronHelper";
+
+// TronScan API endpoints by chainId
+const TRONSCAN_API: Record<number, string> = {
+    728126428: "https://apilist.tronscan.org/api/solidity/contract/verify",   // mainnet
+    3448148188: "https://nile.tronscan.org/api/solidity/contract/verify",     // nile testnet
+};
+
+export interface VerifyOptions {
+    address: string;             // contract address
+    contractName: string;        // e.g. "AuthorityManager"
+    contractPath?: string;       // e.g. "contracts/AuthorityManager.sol:AuthorityManager"
+    constructorArgs?: any[];     // constructor arguments (raw values)
+    constructorParams?: string;  // pre-encoded constructor params hex (without 0x), overrides constructorArgs
+    compiler?: string;           // solc version, defaults to "0.8.25"
+    optimizer?: boolean;         // defaults to true
+    optimizerRuns?: number;      // defaults to 200
+}
+
+/**
+ * Unified contract verification — auto-routes to EVM (hardhat verify) or Tron (TronScan API)
+ */
+export async function verify(hre: any, opts: VerifyOptions): Promise<void> {
+    const network = hre.network.name;
+
+    if (isTronNetwork(network)) {
+        await verifyTron(hre, opts);
+    } else {
+        await verifyEvm(hre, opts);
+    }
+}
+
+// ============================================================
+// EVM verification via hardhat-verify
+// ============================================================
+
+async function verifyEvm(hre: any, opts: VerifyOptions): Promise<void> {
+    const contractPath = opts.contractPath || `contracts/${opts.contractName}.sol:${opts.contractName}`;
+
+    console.log(`verifying ${opts.contractName} at ${opts.address} ...`);
+
+    try {
+        await hre.run("verify:verify", {
+            contract: contractPath,
+            address: opts.address,
+            constructorArguments: opts.constructorArgs || [],
+        });
+        console.log(`${opts.contractName} verified`);
+    } catch (e: any) {
+        if (e.message?.includes("Already Verified")) {
+            console.log(`${opts.contractName} already verified`);
+        } else {
+            console.log(`verification failed: ${e.message || e}`);
+            // Print manual command as fallback
+            const args = (opts.constructorArgs || []).map((a: any) => typeof a === "string" ? `'${a}'` : a).join(" ");
+            console.log(`manual: npx hardhat verify --network ${hre.network.name} --contract ${contractPath} ${opts.address} ${args}`);
+        }
+    }
+}
+
+// ============================================================
+// Tron verification via TronScan API
+// ============================================================
+
+async function verifyTron(hre: any, opts: VerifyOptions): Promise<void> {
+    const chainId = hre.network.config.chainId;
+    const fs = require("fs");
+    const path = require("path");
+
+    // Auto-read compiler settings from hardhat config
+    const solcConfig = hre.config?.solidity?.compilers?.[0] || hre.config?.solidity || {};
+    const compiler = opts.compiler || solcConfig.version || "0.8.25";
+    const optimizer = opts.optimizer ?? solcConfig.settings?.optimizer?.enabled ?? true;
+    const optimizerRuns = opts.optimizerRuns ?? solcConfig.settings?.optimizer?.runs ?? 200;
+    const evmVersion = solcConfig.settings?.evmVersion || "london";
+    const viaIR = solcConfig.settings?.viaIR ? "1" : "0";
+
+    // Convert address to Tron format
+    let address = opts.address;
+    if (address.startsWith("0x")) {
+        address = tronFromHex(address);
+    }
+
+    // Generate flattened source
+    const outputDir = path.join(process.cwd(), "verify-output");
+    const flattenPath = path.join(outputDir, `${opts.contractName}_flatten.sol`);
+
+    console.log(`generating flatten for ${opts.contractName}...`);
+    try {
+        // Find actual source path from artifact
+        const artifact = await hre.artifacts.readArtifact(opts.contractName);
+        const sourcePath = artifact.sourceName; // e.g. "contracts/factory/Create2Factory.sol"
+        let flattenedSource = await hre.run("flatten:get-flattened-sources", {
+            files: [sourcePath],
+        });
+        flattenedSource = removeDuplicateSPDX(flattenedSource);
+        fs.mkdirSync(outputDir, { recursive: true });
+        fs.writeFileSync(flattenPath, flattenedSource);
+        console.log(`flatten saved to: ${flattenPath}`);
+    } catch (e) {
+        if (fs.existsSync(flattenPath)) {
+            console.log(`using existing flatten: ${flattenPath}`);
+        } else {
+            console.log(`flatten failed, generate manually: forge flatten contracts/${opts.contractName}.sol`);
+            return;
+        }
+    }
+
+    // Submit to TronScan API
+    const apiUrl = TRONSCAN_API[chainId];
+    if (!apiUrl) {
+        console.log(`no TronScan API for chainId ${chainId}, printing manual instructions instead`);
+        printTronVerifyInfo(address, opts.contractName, compiler, optimizer, optimizerRuns, evmVersion, flattenPath, chainId);
+        return;
+    }
+
+    console.log(`submitting verification to TronScan for ${address}...`);
+    try {
+        const FormData = require("form-data");
+        const form = new FormData();
+        form.append("contractAddress", address);
+        form.append("contractName", opts.contractName);
+        // Read full compiler version from build-info (includes commit hash)
+        let fullCompiler = `v${compiler}`;
+        try {
+            const buildInfoDir = path.join(process.cwd(), "artifacts/build-info");
+            const buildInfoFiles = fs.readdirSync(buildInfoDir);
+            if (buildInfoFiles.length > 0) {
+                const buildInfo = JSON.parse(fs.readFileSync(
+                    path.join(buildInfoDir, buildInfoFiles[0]), "utf-8"
+                ));
+                if (buildInfo.solcLongVersion) {
+                    fullCompiler = `v${buildInfo.solcLongVersion}`;
+                }
+            }
+        } catch (e: any) {
+            console.log(`[warn] could not read build-info: ${e.message}`);
+        }
+        form.append("compiler", fullCompiler);
+        form.append("license", "3"); // MIT
+        form.append("optimizer", optimizer ? "1" : "0");
+        form.append("runs", String(optimizerRuns));
+        form.append("viaIR", viaIR);
+        form.append("evmVersion", evmVersion);
+        // Encode constructor params from ABI if not pre-encoded
+        let constructorParams = opts.constructorParams || "";
+        if (!constructorParams && opts.constructorArgs && opts.constructorArgs.length > 0) {
+            const { Interface } = require("ethers");
+            const artifact = await hre.artifacts.readArtifact(opts.contractName);
+            const iface = new Interface(artifact.abi);
+            const encoded = iface.encodeDeploy(opts.constructorArgs);
+            constructorParams = encoded.slice(2); // remove 0x
+        }
+        form.append("constructorParams", constructorParams);
+        form.append("files", fs.createReadStream(flattenPath), {
+            filename: `${opts.contractName}.flat.tron.sol`,
+            contentType: "application/octet-stream",
+        });
+
+        const result: any = await new Promise((resolve, reject) => {
+            const url = new URL(apiUrl);
+            const https = require("https");
+            const req = https.request({
+                hostname: url.hostname,
+                path: url.pathname,
+                method: "POST",
+                headers: form.getHeaders(),
+            }, (res: any) => {
+                let data = "";
+                res.on("data", (chunk: string) => data += chunk);
+                res.on("end", () => {
+                    try { resolve(JSON.parse(data)); } catch { resolve({ code: -1, errmsg: data }); }
+                });
+            });
+            req.on("error", reject);
+            form.pipe(req);
+        });
+
+        if (result.code === 200 || result.success) {
+            console.log(`${opts.contractName} verified on TronScan: ${result.data?.message || "success"}`);
+        } else {
+            console.log(`TronScan response:`, JSON.stringify(result, null, 2));
+            printTronVerifyInfo(address, opts.contractName, fullCompiler, optimizer, optimizerRuns, evmVersion, flattenPath, chainId);
+        }
+    } catch (e: any) {
+        console.log(`TronScan API error: ${e.message || e}`);
+        printTronVerifyInfo(address, opts.contractName, `v${compiler}`, optimizer, optimizerRuns, evmVersion, flattenPath, chainId);
+    }
+}
+
+function printTronVerifyInfo(
+    address: string, contractName: string, compiler: string,
+    optimizer: boolean, runs: number, evmVersion: string,
+    flattenPath: string, chainId: number
+) {
+    const isMainnet = chainId === 728126428;
+    const tronscanUrl = isMainnet
+        ? `https://tronscan.org/#/contract/${address}/code`
+        : `https://nile.tronscan.org/#/contract/${address}/code`;
+
+    console.log(`\n=== Verify manually on TronScan ===`);
+    console.log(`Address:    ${address}`);
+    console.log(`Contract:   ${contractName}`);
+    console.log(`Compiler:   ${compiler}`);
+    console.log(`Optimizer:  ${optimizer ? "enabled" : "disabled"}, runs: ${runs}`);
+    console.log(`EVM:        ${evmVersion}`);
+    console.log(`Flatten:    ${flattenPath}`);
+    console.log(`URL:        ${tronscanUrl}`);
+    console.log(`=====================================\n`);
+}
+
+function removeDuplicateSPDX(source: string): string {
+    let found = false;
+    return source.split("\n").filter(line => {
+        if (line.includes("SPDX-License-Identifier")) {
+            if (found) return false;
+            found = true;
+        }
+        return true;
+    }).join("\n");
+}