Add deploy and verify contract

apps/contract-verification/src/app/ContractVerificationPluginClient.ts

@@ -1,16 +1,18 @@
 import { PluginClient } from '@remixproject/plugin'
 import { createClient } from '@remixproject/plugin-webview'
+
 import EventManager from 'events'
-import { VERIFIERS, type ChainSettings, type ContractVerificationSettings, type LookupResponse, type VerifierIdentifier } from './types'
+import { VERIFIERS, type ChainSettings,Chain, type ContractVerificationSettings, type LookupResponse, type VerifierIdentifier, SubmittedContract, SubmittedContracts, VerificationReceipt } from './types'
 import { mergeChainSettingsWithDefaults, validConfiguration } from './utils'
 import { getVerifier } from './Verifiers'
+import { CompilerAbstract } from '@remix-project/remix-solidity'
 
 export class ContractVerificationPluginClient extends PluginClient {
   public internalEvents: EventManager
 
   constructor() {
     super()
-    this.methods = ['lookupAndSave']
+    this.methods = ['lookupAndSave', 'verifyOnDeploy']
     this.internalEvents = new EventManager()
     createClient(this)
     this.onload()
@@ -62,8 +64,156 @@ export class ContractVerificationPluginClient extends PluginClient {
     }
   }
 
+  verifyOnDeploy = async (data: any): Promise<void> => {
+    try {
+      await this.call('terminal', 'log', { type: 'log', value: 'Verification process started...' })
+
+      const { chainId, currentChain, contractAddress, contractName, compilationResult, constructorArgs, etherscanApiKey } = data
+
+      if (!currentChain) {
+        await this.call('terminal', 'log', { type: 'error', value: 'Chain data was not provided for verification.' })
+        return
+      }
+
+      const userSettings = this.getUserSettingsFromLocalStorage()
+
+      if (etherscanApiKey) {
+        if (!userSettings.chains[chainId]) {
+          userSettings.chains[chainId] = { verifiers: {} }
+        }
+
+        if (!userSettings.chains[chainId].verifiers.Etherscan) {
+          userSettings.chains[chainId].verifiers.Etherscan = {}
+        }
+        userSettings.chains[chainId].verifiers.Etherscan.apiKey = etherscanApiKey
+
+        if (!userSettings.chains[chainId].verifiers.Routescan) {
+          userSettings.chains[chainId].verifiers.Routescan = {}
+        }
+        if (!userSettings.chains[chainId].verifiers.Routescan.apiKey){
+          userSettings.chains[chainId].verifiers.Routescan.apiKey = "placeholder"
+        }
+
+        window.localStorage.setItem("contract-verification:settings", JSON.stringify(userSettings))
+
+      }
+
+      const submittedContracts: SubmittedContracts = JSON.parse(window.localStorage.getItem('contract-verification:submitted-contracts') || '{}')
+
+      const filePath = Object.keys(compilationResult.data.contracts).find(path =>
+        compilationResult.data.contracts[path][contractName]
+      )
+      if (!filePath) throw new Error(`Could not find file path for contract ${contractName}`)
+
+      const submittedContract: SubmittedContract = {
+        id: `${chainId}-${contractAddress}`,
+        address: contractAddress,
+        chainId: chainId,
+        filePath: filePath,
+        contractName: contractName,
+        abiEncodedConstructorArgs: constructorArgs,
+        date: new Date().toISOString(),
+        receipts: []
+      }
+
+      const compilerAbstract: CompilerAbstract = compilationResult
+      const chainSettings = mergeChainSettingsWithDefaults(chainId, userSettings)
+
+      if (validConfiguration(chainSettings, 'Sourcify')) {
+        await this._verifyWithProvider('Sourcify', submittedContract, compilerAbstract, chainId, chainSettings)
+      }
+
+      if (currentChain.explorers && currentChain.explorers.some(explorer => explorer.name.toLowerCase().includes('routescan'))) {
+        await this._verifyWithProvider('Routescan', submittedContract, compilerAbstract, chainId, chainSettings)
+      }
+
+      if (currentChain.explorers && currentChain.explorers.some(explorer => explorer.name.toLowerCase().includes('blockscout'))) {
+        await this._verifyWithProvider('Blockscout', submittedContract, compilerAbstract, chainId, chainSettings)
+      }
+
+      if (currentChain.explorers && currentChain.explorers.some(explorer => explorer.name.toLowerCase().includes('etherscan'))) {
+        if (etherscanApiKey) {
+          if (!chainSettings.verifiers.Etherscan) chainSettings.verifiers.Etherscan = {}
+          chainSettings.verifiers.Etherscan.apiKey = etherscanApiKey
+          await this._verifyWithProvider('Etherscan', submittedContract, compilerAbstract, chainId, chainSettings)
+        } else {
+          await this.call('terminal', 'log', { type: 'warn', value: 'Etherscan verification skipped: API key not found in global Settings.' })
+        }
+      }
+
+      submittedContracts[submittedContract.id] = submittedContract
+
+      window.localStorage.setItem('contract-verification:submitted-contracts', JSON.stringify(submittedContracts))
+      this.internalEvents.emit('submissionUpdated')
+    } catch (error) {
+      await this.call('terminal', 'log', { type: 'error', value: `An unexpected error occurred during verification: ${error.message}` })
+    }
+  }
+
+  private _verifyWithProvider = async (
+    providerName: VerifierIdentifier,
+    submittedContract: SubmittedContract,
+    compilerAbstract: CompilerAbstract,
+    chainId: string,
+    chainSettings: ChainSettings
+  ): Promise<void> => {
+    let receipt: VerificationReceipt
+    const verifierSettings = chainSettings.verifiers[providerName]
+    const verifier = getVerifier(providerName, verifierSettings)
+
+    try {
+      if (validConfiguration(chainSettings, providerName)) {
+
+        await this.call('terminal', 'log', { type: 'log', value: `Verifying with ${providerName}...` })
+
+        if (providerName === 'Etherscan' || providerName === 'Routescan' || providerName === 'Blockscout') {
+          await new Promise(resolve => setTimeout(resolve, 10000))
+        }
+
+        if (verifier && typeof verifier.verify === 'function') {
+          const result = await verifier.verify(submittedContract, compilerAbstract)
+
+          receipt = {
+            receiptId: result.receiptId || undefined,
+            verifierInfo: { name: providerName, apiUrl: verifier.apiUrl },
+            status: result.status,
+            message: result.message,
+            lookupUrl: result.lookupUrl,
+            contractId: submittedContract.id,
+            isProxyReceipt: false,
+            failedChecks: 0
+          }
+
+          const successMessage = `${providerName} verification successful.`
+          await this.call('terminal', 'log', { type: 'info', value: successMessage })
+
+          if (result.lookupUrl) {
+            const textMessage = `${result.lookupUrl}`
+            await this.call('terminal', 'log', { type: 'info', value: textMessage })
+          }
+        } else {
+          throw new Error(`${providerName} verifier is not properly configured or does not support direct verification.`)
+        }
+      }
+    } catch (e) {
+      receipt = {
+        verifierInfo: { name: providerName, apiUrl: verifier?.apiUrl || 'N/A' },
+        status: 'failed',
+        message: e.message,
+        contractId: submittedContract.id,
+        isProxyReceipt: false,
+        failedChecks: 0
+      }
+      await this.call('terminal', 'log', { type: 'error', value: `${providerName} verification failed: ${e.message}` })
+    } finally {
+      if (receipt) {
+        submittedContract.receipts.push(receipt)
+      }
+    }
+  }
+
   private getUserSettingsFromLocalStorage(): ContractVerificationSettings {
-    const fallbackSettings = { chains: {} };
+    const fallbackSettings = { chains: {} }
     try {
       const settings = window.localStorage.getItem("contract-verification:settings")
       return settings ? JSON.parse(settings) : fallbackSettings

apps/contract-verification/src/app/app.tsx

@@ -68,9 +68,18 @@ const App = () => {
       .then((data) => setChains(data))
       .catch((error) => console.error('Failed to fetch chains.json:', error))
 
+    const submissionUpdatedListener = () => {
+      const latestSubmissions = window.localStorage.getItem('contract-verification:submitted-contracts')
+      if (latestSubmissions) {
+        setSubmittedContracts(JSON.parse(latestSubmissions))
+      }
+    }
+    plugin.internalEvents.on('submissionUpdated', submissionUpdatedListener)
+
     // Clean up on unmount
     return () => {
       plugin.off('compilerArtefacts' as any, 'compilationSaved')
+      plugin.internalEvents.removeListener('submissionUpdated', submissionUpdatedListener)
     }
   }, [])
 
@@ -167,4 +176,4 @@ const App = () => {
   )
 }
 
-export default App
+export default App

apps/remix-ide-e2e/src/tests/deploy_vefiry.test.ts

@@ -0,0 +1,29 @@
+'use strict'
+import { NightwatchBrowser } from 'nightwatch'
+import init from '../helpers/init'
+
+declare global {
+  interface Window { testplugin: { name: string, url: string }; }
+}
+
+module.exports = {
+  '@disabled': true,
+  before: function (browser: NightwatchBrowser, done: VoidFunction) {
+    init(browser, done, null)
+  },
+
+  'Should NOT display the "Verify Contract" checkbox on an unsupported network (Remix VM) #group1': function (browser: NightwatchBrowser) {
+    browser
+      .waitForElementVisible('*[data-id="remixIdeSidePanel"]')
+      .clickLaunchIcon('filePanel')
+      .click('*[data-id="treeViewLitreeViewItemcontracts"]')
+      .openFile('contracts/1_Storage.sol')
+      .clickLaunchIcon('udapp')
+      .waitForElementVisible('*[data-id="Deploy - transact (not payable)"]')
+      .waitForElementNotPresent({
+        selector: '#deployAndRunVerifyContract',
+        timeout: 5000
+      })
+      .end()
+  }
+}

libs/remix-ui/remix-ai-assistant/src/components/chat.tsx

@@ -47,7 +47,6 @@ const AiChatIntro: React.FC<AiChatIntroProps> = ({ sendPrompt }) => {
       {/* Dynamic Conversation Starters */}
       <div className="d-flex flex-column mt-3" style={{ maxWidth: '400px' }}>
         {conversationStarters.map((starter, index) => (
-
           <button
             key={`${starter.level}-${index}`}
             data-id={`remix-ai-assistant-starter-${starter.level}-${index}`}

libs/remix-ui/run-tab/src/lib/actions/deploy.ts

@@ -161,7 +161,8 @@ export const createInstance = async (
   mainnetPrompt: MainnetPrompt,
   isOverSizePrompt: (values: OverSizeLimit) => JSX.Element,
   args,
-  deployMode: DeployMode[]) => {
+  deployMode: DeployMode[],
+  isVerifyChecked: boolean) => {
   const isProxyDeployment = (deployMode || []).find(mode => mode === 'Deploy with Proxy')
   const isContractUpgrade = (deployMode || []).find(mode => mode === 'Upgrade with Proxy')
   const statusCb = (msg: string) => {
@@ -173,22 +174,63 @@ export const createInstance = async (
   const finalCb = async (error, contractObject, address) => {
     if (error) {
       const log = logBuilder(error)
-
       return terminalLogger(plugin, log)
     }
+
     addInstance(dispatch, { contractData: contractObject, address, name: contractObject.name })
     const data = await plugin.compilersArtefacts.getCompilerAbstract(contractObject.contract.file)
-
     plugin.compilersArtefacts.addResolvedContract(addressToString(address), data)
-    if (plugin.REACT_API.ipfsChecked) {
-      _paq.push(['trackEvent', 'udapp', 'DeployAndPublish', plugin.REACT_API.networkName])
-      publishToStorage('ipfs', selectedContract)
+
+    if (isVerifyChecked) {
+      _paq.push(['trackEvent', 'udapp', 'DeployAndVerify', plugin.REACT_API.networkName])
+
+      try {
+        const status = plugin.blockchain.getCurrentNetworkStatus()
+        if (status.error || !status.network) {
+          throw new Error(`Could not get network status: ${status.error || 'Unknown error'}`)
+        }
+        const currentChainId = parseInt(status.network.id)
+
+        const response = await fetch('https://chainid.network/chains.json')
+        if (!response.ok) throw new Error('Could not fetch chains list from chainid.network.')
+        const allChains = await response.json()
+        const currentChain = allChains.find(chain => chain.chainId === currentChainId)
+
+        if (!currentChain) {
+          const errorMsg = `The current network (Chain ID: ${currentChainId}) is not supported for verification via this plugin. Please switch to a supported network like Sepolia or Mainnet.`
+          const errorLog = logBuilder(errorMsg)
+          terminalLogger(plugin, errorLog)
+          return
+        }
+
+        const etherscanApiKey = await plugin.call('config', 'getAppParameter', 'etherscan-access-token')
+
+        const verificationData = {
+          chainId: currentChainId.toString(),
+          currentChain: currentChain,
+          contractAddress: addressToString(address),
+          contractName: selectedContract.name,
+          compilationResult: await plugin.compilersArtefacts.getCompilerAbstract(selectedContract.contract.file),
+          constructorArgs: args,
+          etherscanApiKey: etherscanApiKey
+        }
+
+        setTimeout(async () => {
+          await plugin.call('contract-verification', 'verifyOnDeploy', verificationData)
+        }, 1000)
+
+      } catch (e) {
+        const errorMsg = `Verification setup failed: ${e.message}`
+        const errorLog = logBuilder(errorMsg)
+        terminalLogger(plugin, errorLog)
+      }
+
     } else {
       _paq.push(['trackEvent', 'udapp', 'DeployOnly', plugin.REACT_API.networkName])
     }
+
     if (isProxyDeployment) {
       const initABI = contractObject.abi.find(abi => abi.name === 'initialize')
-
       plugin.call('openzeppelin-proxy', 'executeUUPSProxy', addressToString(address), args, initABI, contractObject)
     } else if (isContractUpgrade) {
       plugin.call('openzeppelin-proxy', 'executeUUPSContractUpgrade', args, addressToString(address), contractObject)

libs/remix-ui/run-tab/src/lib/actions/index.ts

@@ -45,7 +45,7 @@ export const setPassphraseModal = (passphrase: string) => setPassphrasePrompt(di
 export const setMatchPassphraseModal = (passphrase: string) => setMatchPassphrasePrompt(dispatch, passphrase)
 export const signMessage = (account: string, message: string, modalContent: (hash: string, data: string) => JSX.Element, passphrase?: string) => signMessageWithAddress(plugin, dispatch, account, message, modalContent, passphrase)
 export const fetchSelectedContract = (contractName: string, compiler: CompilerAbstractType) => getSelectedContract(contractName, compiler)
-export const createNewInstance = async (selectedContract: ContractData, gasEstimationPrompt: (msg: string) => JSX.Element, passphrasePrompt: (msg: string) => JSX.Element, publishToStorage: (storage: 'ipfs' | 'swarm', contract: ContractData) => void, mainnetPrompt: MainnetPrompt, isOverSizePrompt: (values: OverSizeLimit) => JSX.Element, args, deployMode: DeployMode[]) => createInstance(plugin, dispatch, selectedContract, gasEstimationPrompt, passphrasePrompt, publishToStorage, mainnetPrompt, isOverSizePrompt, args, deployMode)
+export const createNewInstance = async (selectedContract: ContractData, gasEstimationPrompt: (msg: string) => JSX.Element, passphrasePrompt: (msg: string) => JSX.Element, publishToStorage: (storage: 'ipfs' | 'swarm', contract: ContractData) => void, mainnetPrompt: MainnetPrompt, isOverSizePrompt: (values: OverSizeLimit) => JSX.Element, args, deployMode: DeployMode[], isVerifyChecked: boolean) => createInstance(plugin, dispatch, selectedContract, gasEstimationPrompt, passphrasePrompt, publishToStorage, mainnetPrompt, isOverSizePrompt, args, deployMode, isVerifyChecked)
 export const setSendValue = (value: string) => setSendTransactionValue(dispatch, value)
 export const setBaseFeePerGas = (baseFee: string) => updateBaseFeePerGas(dispatch, baseFee)
 export const setConfirmSettings = (confirmation: boolean) => updateConfirmSettings(dispatch, confirmation)