use crate::{Client, Response, Result};
use ethers_core::types::Address;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VerifyContract {
#[serde(rename = "contractaddress")]
pub address: Address,
#[serde(rename = "sourceCode")]
pub source: String,
#[serde(rename = "codeformat")]
pub code_format: CodeFormat,
#[serde(rename = "contractname")]
pub contract_name: String,
#[serde(rename = "compilerversion")]
pub compiler_version: String,
#[serde(rename = "optimizationUsed", skip_serializing_if = "Option::is_none")]
pub optimization_used: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub runs: Option<String>,
#[serde(rename = "constructorArguements", skip_serializing_if = "Option::is_none")]
pub constructor_arguments: Option<String>,
#[serde(rename = "constructorArguments", skip_serializing_if = "Option::is_none")]
pub blockscout_constructor_arguments: Option<String>,
#[serde(rename = "evmversion", skip_serializing_if = "Option::is_none")]
pub evm_version: Option<String>,
#[serde(flatten)]
pub other: HashMap<String, String>,
}
impl VerifyContract {
pub fn new(
address: Address,
contract_name: String,
source: String,
compiler_version: String,
) -> Self {
Self {
address,
source,
code_format: Default::default(),
contract_name,
compiler_version,
optimization_used: None,
runs: None,
constructor_arguments: None,
blockscout_constructor_arguments: None,
evm_version: None,
other: Default::default(),
}
}
#[must_use]
pub fn runs(mut self, runs: u32) -> Self {
self.runs = Some(format!("{runs}"));
self
}
#[must_use]
pub fn optimization(self, optimization: bool) -> Self {
if optimization {
self.optimized()
} else {
self.not_optimized()
}
}
#[must_use]
pub fn optimized(mut self) -> Self {
self.optimization_used = Some("1".to_string());
self
}
#[must_use]
pub fn not_optimized(mut self) -> Self {
self.optimization_used = Some("0".to_string());
self
}
#[must_use]
pub fn code_format(mut self, code_format: CodeFormat) -> Self {
self.code_format = code_format;
self
}
#[must_use]
pub fn evm_version(mut self, evm_version: impl Into<String>) -> Self {
self.evm_version = Some(evm_version.into());
self
}
#[must_use]
pub fn constructor_arguments(
mut self,
constructor_arguments: Option<impl Into<String>>,
) -> Self {
let constructor_args = constructor_arguments.map(|s| {
s.into()
.trim()
.trim_start_matches("0x")
.to_string()
});
self.constructor_arguments = constructor_args.clone();
self.blockscout_constructor_arguments = constructor_args;
self
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VerifyProxyContract {
pub address: Address,
#[serde(default, rename = "expectedimplementation", skip_serializing_if = "Option::is_none")]
pub expected_impl: Option<Address>,
}
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum CodeFormat {
#[serde(rename = "solidity-single-file")]
SingleFile,
#[default]
#[serde(rename = "solidity-standard-json-input")]
StandardJsonInput,
}
impl AsRef<str> for CodeFormat {
fn as_ref(&self) -> &str {
match self {
CodeFormat::SingleFile => "solidity-single-file",
CodeFormat::StandardJsonInput => "solidity-standard-json-input",
}
}
}
impl Client {
pub async fn submit_contract_verification(
&self,
contract: &VerifyContract,
) -> Result<Response<String>> {
let body = self.create_query("contract", "verifysourcecode", contract);
self.post_form(&body).await
}
pub async fn check_contract_verification_status(
&self,
guid: impl AsRef<str>,
) -> Result<Response<String>> {
let body = self.create_query(
"contract",
"checkverifystatus",
HashMap::from([("guid", guid.as_ref())]),
);
self.post_form(&body).await
}
pub async fn submit_proxy_contract_verification(
&self,
contract: &VerifyProxyContract,
) -> Result<Response<String>> {
let body = self.create_query("contract", "verifyproxycontract", contract);
self.post_form(&body).await
}
pub async fn check_proxy_contract_verification_status(
&self,
guid: impl AsRef<str>,
) -> Result<Response<String>> {
let body = self.create_query(
"contract",
"checkproxyverification",
HashMap::from([("guid", guid.as_ref())]),
);
self.post_form(&body).await
}
}