401 lines
17 KiB
Rust
401 lines
17 KiB
Rust
//! Module implements reading of contract artifacts from various sources.
|
|
use super::util;
|
|
use ethers_core::types::Address;
|
|
|
|
use crate::util::resolve_path;
|
|
use cfg_if::cfg_if;
|
|
use eyre::{eyre, Context, Error, Result};
|
|
use std::{env, fs, path::Path, str::FromStr};
|
|
use url::Url;
|
|
|
|
/// A source of a Truffle artifact JSON.
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
pub enum Source {
|
|
/// A raw ABI string
|
|
String(String),
|
|
|
|
/// An ABI located on the local file system.
|
|
Local(String),
|
|
|
|
/// An ABI to be retrieved over HTTP(S).
|
|
Http(Url),
|
|
|
|
/// An address of a mainnet contract that has been verified on Bscscan.com.
|
|
Bscscan(Address),
|
|
|
|
/// An address of a mainnet contract that has been verified on Etherscan.io.
|
|
Etherscan(Address),
|
|
|
|
/// An address of a mainnet contract that has been verified on Polygonscan.com.
|
|
Polygonscan(Address),
|
|
|
|
/// An address of a mainnet contract that has been verified on snowtrace.io.
|
|
Snowtrace(Address),
|
|
|
|
/// The package identifier of an npm package with a path to a Truffle
|
|
/// artifact or ABI to be retrieved from `unpkg.io`.
|
|
Npm(String),
|
|
}
|
|
|
|
impl Source {
|
|
/// Parses an ABI from a source
|
|
///
|
|
/// Contract ABIs can be retrieved from the local filesystem or online
|
|
/// from `etherscan.io`. They can also be provided in-line. This method parses
|
|
/// ABI source URLs and accepts the following:
|
|
///
|
|
/// - raw ABI JSON
|
|
///
|
|
/// - `relative/path/to/Contract.json`: a relative path to an ABI JSON file.
|
|
/// This relative path is rooted in the current working directory.
|
|
/// To specify the root for relative paths, use `Source::with_root`.
|
|
///
|
|
/// - `/absolute/path/to/Contract.json` or `file:///absolute/path/to/Contract.json`: an absolute
|
|
/// path or file URL to an ABI JSON file.
|
|
///
|
|
/// - `http(s)://...` an HTTP url to a contract ABI.
|
|
///
|
|
/// - `etherscan:0xXX..XX` or `https://etherscan.io/address/0xXX..XX`: a address or URL of a
|
|
/// verified contract on Etherscan.
|
|
/// - `bscscan:0xXX..XX` or `https://bscscan.io/address/0xXX..XX`: a address or URL of a
|
|
/// verified contract on Bscscan.
|
|
/// - `polygonscan:0xXX..XX` or `https://polygonscan.io/address/0xXX..XX`: a address or URL of a
|
|
/// verified contract on Polygonscan.
|
|
/// - `snowtrace:0xXX..XX` or `https://snowtrace.io/address/0xXX..XX`: a address or URL of a
|
|
/// verified contract on Snowtrace.
|
|
/// - `npm:@org/package@1.0.0/path/to/contract.json` an npmjs package with an optional version
|
|
/// and path (defaulting to the latest version and `index.js`). The contract ABI will be
|
|
/// retrieved through `unpkg.io`.
|
|
pub fn parse<S>(source: S) -> Result<Self>
|
|
where
|
|
S: AsRef<str>,
|
|
{
|
|
let source = source.as_ref();
|
|
if matches!(source.chars().next(), Some('[' | '{')) {
|
|
return Ok(Source::String(source.to_owned()))
|
|
}
|
|
let root = env::var("CARGO_MANIFEST_DIR")?;
|
|
Source::with_root(root, source)
|
|
}
|
|
|
|
/// Parses an artifact source from a string and a specified root directory
|
|
/// for resolving relative paths. See `Source::with_root` for more details
|
|
/// on supported source strings.
|
|
fn with_root<P, S>(root: P, source: S) -> Result<Self>
|
|
where
|
|
P: AsRef<Path>,
|
|
S: AsRef<str>,
|
|
{
|
|
let source = source.as_ref();
|
|
let root = root.as_ref();
|
|
cfg_if! {
|
|
if #[cfg(target_arch = "wasm32")] {
|
|
let root = if root.starts_with("/") {
|
|
format!("file:://{}", root.display())
|
|
} else {
|
|
format!("{}", root.display())
|
|
};
|
|
let base = Url::parse(&root)
|
|
.map_err(|_| eyre!("root path '{}' is not absolute", root))?;
|
|
} else {
|
|
let base = Url::from_directory_path(root)
|
|
.map_err(|_| eyre!("root path '{}' is not absolute", root.display()))?;
|
|
}
|
|
}
|
|
let url = base.join(source)?;
|
|
|
|
match url.scheme() {
|
|
"file" => Ok(Source::local(source)),
|
|
"http" | "https" => match url.host_str() {
|
|
Some("bscscan.com") => Source::etherscan(
|
|
url.path()
|
|
.rsplit('/')
|
|
.next()
|
|
.ok_or_else(|| eyre!("HTTP URL does not have a path"))?,
|
|
),
|
|
Some("etherscan.io") => Source::etherscan(
|
|
url.path()
|
|
.rsplit('/')
|
|
.next()
|
|
.ok_or_else(|| eyre!("HTTP URL does not have a path"))?,
|
|
),
|
|
Some("polygonscan.com") => Source::polygonscan(
|
|
url.path()
|
|
.rsplit('/')
|
|
.next()
|
|
.ok_or_else(|| eyre!("HTTP URL does not have a path"))?,
|
|
),
|
|
Some("snowtrace.io") => Source::snowtrace(
|
|
url.path()
|
|
.rsplit('/')
|
|
.next()
|
|
.ok_or_else(|| eyre!("HTTP URL does not have a path"))?,
|
|
),
|
|
_ => Ok(Source::Http(url)),
|
|
},
|
|
"bscscan" => Source::bscscan(url.path()),
|
|
"etherscan" => Source::etherscan(url.path()),
|
|
"polygonscan" => Source::polygonscan(url.path()),
|
|
"snowtrace" => Source::snowtrace(url.path()),
|
|
"npm" => Ok(Source::npm(url.path())),
|
|
_ => Err(eyre!("unsupported URL '{}'", url)),
|
|
}
|
|
}
|
|
|
|
/// Creates a local filesystem source from a path string.
|
|
pub fn local(path: impl Into<String>) -> Self {
|
|
Source::Local(path.into())
|
|
}
|
|
|
|
/// Creates an HTTP source from a URL.
|
|
pub fn http<S>(url: S) -> Result<Self>
|
|
where
|
|
S: AsRef<str>,
|
|
{
|
|
Ok(Source::Http(Url::parse(url.as_ref())?))
|
|
}
|
|
|
|
/// Creates an Bscscan source from an address string.
|
|
pub fn bscscan<S>(address: S) -> Result<Self>
|
|
where
|
|
S: AsRef<str>,
|
|
{
|
|
let address =
|
|
util::parse_address(address).context("failed to parse address for Bscscan source")?;
|
|
Ok(Source::Bscscan(address))
|
|
}
|
|
|
|
/// Creates an Etherscan source from an address string.
|
|
pub fn etherscan<S>(address: S) -> Result<Self>
|
|
where
|
|
S: AsRef<str>,
|
|
{
|
|
let address =
|
|
util::parse_address(address).context("failed to parse address for Etherscan source")?;
|
|
Ok(Source::Etherscan(address))
|
|
}
|
|
|
|
/// Creates an Polygonscan source from an address string.
|
|
pub fn polygonscan<S>(address: S) -> Result<Self>
|
|
where
|
|
S: AsRef<str>,
|
|
{
|
|
let address = util::parse_address(address)
|
|
.context("failed to parse address for Polygonscan source")?;
|
|
Ok(Source::Polygonscan(address))
|
|
}
|
|
|
|
/// Creates an Snowtrace source from an address string.
|
|
pub fn snowtrace<S>(address: S) -> Result<Self>
|
|
where
|
|
S: AsRef<str>,
|
|
{
|
|
let address =
|
|
util::parse_address(address).context("failed to parse address for Snowtrace source")?;
|
|
Ok(Source::Snowtrace(address))
|
|
}
|
|
|
|
/// Creates an Etherscan source from an address string.
|
|
pub fn npm<S>(package_path: S) -> Self
|
|
where
|
|
S: Into<String>,
|
|
{
|
|
Source::Npm(package_path.into())
|
|
}
|
|
|
|
/// Retrieves the source JSON of the artifact this will either read the JSON
|
|
/// from the file system or retrieve a contract ABI from the network
|
|
/// depending on the source type.
|
|
pub fn get(&self) -> Result<String> {
|
|
cfg_if! {
|
|
if #[cfg(target_arch = "wasm32")] {
|
|
match self {
|
|
Source::Local(path) => get_local_contract(path),
|
|
Source::Http(_) => panic!("Http abi location are not supported for wasm"),
|
|
Source::Bscscan(_) => panic!("Bscscan abi location are not supported for wasm"),
|
|
Source::Etherscan(_) => panic!("Etherscan abi location are not supported for wasm"),
|
|
Source::Polygonscan(_) => panic!("Polygonscan abi location are not supported for wasm"),
|
|
Source::Snowtrace(_) => panic!("Snowtrace abi location are not supported for wasm"),
|
|
Source::Npm(_) => panic!("npm abi location are not supported for wasm"),
|
|
Source::String(abi) => Ok(abi.clone()),
|
|
}
|
|
} else {
|
|
match self {
|
|
Source::Local(path) => get_local_contract(path),
|
|
Source::Http(url) => get_http_contract(url),
|
|
Source::Bscscan(address) => get_etherscan_contract(*address, "bscscan.com"),
|
|
Source::Etherscan(address) => get_etherscan_contract(*address, "etherscan.io"),
|
|
Source::Polygonscan(address) => get_etherscan_contract(*address, "polygonscan.com"),
|
|
Source::Snowtrace(address) => get_etherscan_contract(*address, "snowtrace.io"),
|
|
Source::Npm(package) => get_npm_contract(package),
|
|
Source::String(abi) => Ok(abi.clone()),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl FromStr for Source {
|
|
type Err = Error;
|
|
|
|
fn from_str(s: &str) -> Result<Self> {
|
|
Source::parse(s)
|
|
}
|
|
}
|
|
|
|
/// Reads an artifact JSON file from the local filesystem.
|
|
///
|
|
/// The given path can be relative or absolute and can contain env vars like
|
|
/// `"$CARGO_MANIFEST_DIR/contracts/a.json"`
|
|
/// If the path is relative after all env vars have been resolved then we assume the root is either
|
|
/// `CARGO_MANIFEST_DIR` or the current working directory.
|
|
fn get_local_contract(path: impl AsRef<str>) -> Result<String> {
|
|
let path = resolve_path(path.as_ref())?;
|
|
let path = if path.is_relative() {
|
|
let manifest_path = env::var("CARGO_MANIFEST_DIR")?;
|
|
let root = Path::new(&manifest_path);
|
|
let mut contract_path = root.join(&path);
|
|
if !contract_path.exists() {
|
|
contract_path = dunce::canonicalize(&path)?;
|
|
}
|
|
if !contract_path.exists() {
|
|
eyre::bail!("Unable to find local contract \"{}\"", path.display())
|
|
}
|
|
contract_path
|
|
} else {
|
|
path
|
|
};
|
|
|
|
let json = fs::read_to_string(&path)
|
|
.context(format!("failed to read artifact JSON file with path {}", &path.display()))?;
|
|
Ok(json)
|
|
}
|
|
|
|
/// Retrieves a Truffle artifact or ABI from an HTTP URL.
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
fn get_http_contract(url: &Url) -> Result<String> {
|
|
let json = util::http_get(url.as_str())
|
|
.with_context(|| format!("failed to retrieve JSON from {url}"))?;
|
|
Ok(json)
|
|
}
|
|
|
|
/// Retrieves a contract ABI from the Etherscan HTTP API and wraps it in an
|
|
/// artifact JSON for compatibility with the code generation facilities.
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
fn get_etherscan_contract(address: Address, domain: &str) -> Result<String> {
|
|
// NOTE: We do not retrieve the bytecode since deploying contracts with the
|
|
// same bytecode is unreliable as the libraries have already linked and
|
|
// probably don't reference anything when deploying on other networks.
|
|
let api_key = {
|
|
let key_res = match domain {
|
|
"bscscan.com" => env::var("BSCSCAN_API_KEY").ok(),
|
|
"etherscan.io" => env::var("ETHERSCAN_API_KEY").ok(),
|
|
"polygonscan.com" => env::var("POLYGONSCAN_API_KEY").ok(),
|
|
"snowtrace.io" => env::var("SNOWTRACE_API_KEY").ok(),
|
|
_ => None,
|
|
};
|
|
key_res.map(|key| format!("&apikey={key}")).unwrap_or_default()
|
|
};
|
|
|
|
let abi_url = format!(
|
|
"http://api.{domain}/api?module=contract&action=getabi&address={address:?}&format=raw{api_key}",
|
|
);
|
|
let abi = util::http_get(&abi_url).context(format!("failed to retrieve ABI from {domain}"))?;
|
|
|
|
if abi.starts_with("Contract source code not verified") {
|
|
eyre::bail!("Contract source code not verified: {:?}", address);
|
|
}
|
|
if abi.starts_with('{') && abi.contains("Max rate limit reached") {
|
|
eyre::bail!(
|
|
"Max rate limit reached, please use etherscan API Key for higher rate limit: {:?}",
|
|
address
|
|
);
|
|
}
|
|
|
|
Ok(abi)
|
|
}
|
|
|
|
/// Retrieves a Truffle artifact or ABI from an npm package through `unpkg.io`.
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
fn get_npm_contract(package: &str) -> Result<String> {
|
|
let unpkg_url = format!("https://unpkg.io/{package}");
|
|
let json = util::http_get(&unpkg_url)
|
|
.with_context(|| format!("failed to retrieve JSON from for npm package {package}"))?;
|
|
|
|
Ok(json)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn parse_source() {
|
|
let root = "/rooted";
|
|
for (url, expected) in &[
|
|
("relative/Contract.json", Source::local("/rooted/relative/Contract.json")),
|
|
("/absolute/Contract.json", Source::local("/absolute/Contract.json")),
|
|
(
|
|
"https://my.domain.eth/path/to/Contract.json",
|
|
Source::http("https://my.domain.eth/path/to/Contract.json").unwrap(),
|
|
),
|
|
(
|
|
"bscscan:0x0001020304050607080910111213141516171819",
|
|
Source::bscscan("0x0001020304050607080910111213141516171819").unwrap(),
|
|
),
|
|
(
|
|
"etherscan:0x0001020304050607080910111213141516171819",
|
|
Source::etherscan("0x0001020304050607080910111213141516171819").unwrap(),
|
|
),
|
|
(
|
|
"polygonscan:0x0001020304050607080910111213141516171819",
|
|
Source::polygonscan("0x0001020304050607080910111213141516171819").unwrap(),
|
|
),
|
|
(
|
|
"snowtrace:0x0001020304050607080910111213141516171819",
|
|
Source::snowtrace("0x0001020304050607080910111213141516171819").unwrap(),
|
|
),
|
|
(
|
|
"https://bscscan.io/address/0x0001020304050607080910111213141516171819",
|
|
Source::bscscan("0x0001020304050607080910111213141516171819").unwrap(),
|
|
),
|
|
(
|
|
"https://etherscan.io/address/0x0001020304050607080910111213141516171819",
|
|
Source::etherscan("0x0001020304050607080910111213141516171819").unwrap(),
|
|
),
|
|
(
|
|
"https://polygonscan.com/address/0x0001020304050607080910111213141516171819",
|
|
Source::polygonscan("0x0001020304050607080910111213141516171819").unwrap(),
|
|
),
|
|
(
|
|
"https://snowtrace.io/address/0x0001020304050607080910111213141516171819",
|
|
Source::snowtrace("0x0001020304050607080910111213141516171819").unwrap(),
|
|
),
|
|
(
|
|
"npm:@openzeppelin/contracts@2.5.0/build/contracts/IERC20.json",
|
|
Source::npm("@openzeppelin/contracts@2.5.0/build/contracts/IERC20.json"),
|
|
),
|
|
] {
|
|
let source = Source::with_root(root, url).unwrap();
|
|
assert_eq!(source, *expected);
|
|
}
|
|
|
|
let src = r#"[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"name","type":"string"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"symbol","type":"string"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"decimals","type":"uint8"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"spender","type":"address"},{"name":"value","type":"uint256"}],"name":"approve","outputs":[{"name":"success","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"totalSupply","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"from","type":"address"},{"name":"to","type":"address"},{"name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"success","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"who","type":"address"}],"name":"balanceOf","outputs":[{"name":"balance","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"value","type":"uint256"}],"name":"transfer","outputs":[{"name":"success","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"owner","type":"address"},{"name":"spender","type":"address"}],"name":"allowance","outputs":[{"name":"remaining","type":"uint256"}],"payable":false,"type":"function"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"},{"indexed":true,"name":"spender","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Transfer","type":"event"}]"#;
|
|
let parsed = Source::parse(src).unwrap();
|
|
assert_eq!(parsed, Source::String(src.to_owned()));
|
|
|
|
let hardhat_src = format!(
|
|
r#"{{"_format": "hh-sol-artifact-1", "contractName": "Verifier", "sourceName": "contracts/verifier.sol", "abi": {src}, "bytecode": "0x", "deployedBytecode": "0x", "linkReferences": {{}}, "deployedLinkReferences": {{}}}}"#,
|
|
);
|
|
let hardhat_parsed = Source::parse(&hardhat_src).unwrap();
|
|
assert_eq!(hardhat_parsed, Source::String(hardhat_src));
|
|
}
|
|
|
|
#[test]
|
|
#[ignore]
|
|
fn get_etherscan_contract() {
|
|
let source = Source::etherscan("0x6b175474e89094c44da98b954eedeac495271d0f").unwrap();
|
|
let _dai = source.get().unwrap();
|
|
}
|
|
}
|