396 lines
13 KiB
Rust
396 lines
13 KiB
Rust
// Copyright 2015-2019 Parity Technologies (UK) Ltd.
|
|
// This file is part of Parity Ethereum.
|
|
|
|
// Parity Ethereum is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// Parity Ethereum is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Parity Ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
//! URLHint Contract
|
|
|
|
use mime::{self, Mime};
|
|
use mime_guess;
|
|
use rustc_hex::ToHex;
|
|
use std::sync::Arc;
|
|
|
|
use ethereum_types::{Address, H256};
|
|
use futures::{future, future::Either, Future};
|
|
use registrar::{Asynchronous, Registrar, RegistrarClient};
|
|
|
|
use_contract!(urlhint, "res/urlhint.json");
|
|
|
|
const COMMIT_LEN: usize = 20;
|
|
const GITHUB_HINT: &'static str = "githubhint";
|
|
/// GithubHint entries with commit set as `0x0..01` should be treated
|
|
/// as Github Dapp, downloadable zip files, than can be extracted, containing
|
|
/// the manifest.json file along with the dapp
|
|
static GITHUB_DAPP_COMMIT: &[u8; COMMIT_LEN] =
|
|
&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
|
|
|
|
/// Github-hosted dapp.
|
|
#[derive(Debug, PartialEq)]
|
|
pub struct GithubApp {
|
|
/// Github Account
|
|
pub account: String,
|
|
/// Github Repository
|
|
pub repo: String,
|
|
/// Commit on Github
|
|
pub commit: [u8; COMMIT_LEN],
|
|
/// Dapp owner address
|
|
pub owner: Address,
|
|
}
|
|
|
|
impl GithubApp {
|
|
/// Returns URL of this Github-hosted dapp package.
|
|
pub fn url(&self) -> String {
|
|
// Since https fetcher doesn't support redirections we use direct link
|
|
// format!("https://github.com/{}/{}/archive/{}.zip", self.account, self.repo, self.commit.to_hex())
|
|
format!(
|
|
"https://codeload.github.com/{}/{}/zip/{}",
|
|
self.account,
|
|
self.repo,
|
|
self.commit.to_hex()
|
|
)
|
|
}
|
|
|
|
fn commit(bytes: &[u8]) -> Option<[u8; COMMIT_LEN]> {
|
|
if bytes.len() < COMMIT_LEN {
|
|
return None;
|
|
}
|
|
|
|
let mut commit = [0; COMMIT_LEN];
|
|
for i in 0..COMMIT_LEN {
|
|
commit[i] = bytes[i];
|
|
}
|
|
|
|
Some(commit)
|
|
}
|
|
}
|
|
|
|
/// Hash-Addressed Content
|
|
#[derive(Debug, PartialEq)]
|
|
pub struct Content {
|
|
/// URL of the content
|
|
pub url: String,
|
|
/// MIME type of the content
|
|
pub mime: Mime,
|
|
/// Content owner address
|
|
pub owner: Address,
|
|
}
|
|
|
|
/// Result of resolving id to URL
|
|
#[derive(Debug, PartialEq)]
|
|
pub enum URLHintResult {
|
|
/// Dapp
|
|
Dapp(GithubApp),
|
|
/// GithubDapp
|
|
GithubDapp(Content),
|
|
/// Content
|
|
Content(Content),
|
|
}
|
|
|
|
/// URLHint Contract interface
|
|
pub trait URLHint: Send + Sync {
|
|
/// Resolves given id to registrar entry.
|
|
fn resolve(
|
|
&self,
|
|
id: H256,
|
|
) -> Box<dyn Future<Item = Option<URLHintResult>, Error = String> + Send>;
|
|
}
|
|
|
|
/// `URLHintContract` API
|
|
pub struct URLHintContract {
|
|
registrar: Registrar,
|
|
client: Arc<dyn RegistrarClient<Call = Asynchronous>>,
|
|
}
|
|
|
|
impl URLHintContract {
|
|
/// Creates new `URLHintContract`
|
|
pub fn new(client: Arc<dyn RegistrarClient<Call = Asynchronous>>) -> Self {
|
|
URLHintContract {
|
|
registrar: Registrar::new(client.clone()),
|
|
client: client,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn get_urlhint_content(account_slash_repo: String, owner: Address) -> Content {
|
|
let mime = guess_mime_type(&account_slash_repo).unwrap_or(mime::APPLICATION_JSON);
|
|
Content {
|
|
url: account_slash_repo,
|
|
mime,
|
|
owner,
|
|
}
|
|
}
|
|
|
|
fn decode_urlhint_output(output: (String, [u8; 20], Address)) -> Option<URLHintResult> {
|
|
let (account_slash_repo, commit, owner) = output;
|
|
|
|
if owner == Address::default() {
|
|
return None;
|
|
}
|
|
|
|
let commit = GithubApp::commit(&commit);
|
|
|
|
if commit == Some(Default::default()) {
|
|
let content = get_urlhint_content(account_slash_repo, owner);
|
|
return Some(URLHintResult::Content(content));
|
|
}
|
|
|
|
if commit == Some(*GITHUB_DAPP_COMMIT) {
|
|
let content = get_urlhint_content(account_slash_repo, owner);
|
|
return Some(URLHintResult::GithubDapp(content));
|
|
}
|
|
|
|
let (account, repo) = {
|
|
let mut it = account_slash_repo.split('/');
|
|
match (it.next(), it.next()) {
|
|
(Some(account), Some(repo)) => (account.into(), repo.into()),
|
|
_ => return None,
|
|
}
|
|
};
|
|
|
|
commit.map(|commit| {
|
|
URLHintResult::Dapp(GithubApp {
|
|
account: account,
|
|
repo: repo,
|
|
commit: commit,
|
|
owner: owner,
|
|
})
|
|
})
|
|
}
|
|
|
|
impl URLHint for URLHintContract {
|
|
fn resolve(
|
|
&self,
|
|
id: H256,
|
|
) -> Box<dyn Future<Item = Option<URLHintResult>, Error = String> + Send> {
|
|
let client = self.client.clone();
|
|
|
|
let future = self
|
|
.registrar
|
|
.get_address(GITHUB_HINT)
|
|
.and_then(move |addr| {
|
|
if !addr.is_zero() {
|
|
let data = urlhint::functions::entries::encode_input(id);
|
|
let result = client
|
|
.call_contract(addr, data)
|
|
.and_then(move |output| {
|
|
urlhint::functions::entries::decode_output(&output)
|
|
.map_err(|e| e.to_string())
|
|
})
|
|
.map(decode_urlhint_output);
|
|
Either::B(result)
|
|
} else {
|
|
Either::A(future::ok(None))
|
|
}
|
|
});
|
|
Box::new(future)
|
|
}
|
|
}
|
|
|
|
fn guess_mime_type(url: &str) -> Option<Mime> {
|
|
const CONTENT_TYPE: &'static str = "content-type=";
|
|
|
|
let mut it = url.split('#');
|
|
// skip url
|
|
let url = it.next();
|
|
// get meta headers
|
|
let metas = it.next();
|
|
if let Some(metas) = metas {
|
|
for meta in metas.split('&') {
|
|
let meta = meta.to_lowercase();
|
|
if meta.starts_with(CONTENT_TYPE) {
|
|
return meta[CONTENT_TYPE.len()..].parse().ok();
|
|
}
|
|
}
|
|
}
|
|
url.and_then(|url| url.split('.').last())
|
|
.and_then(|extension| mime_guess::from_ext(extension).first())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub mod tests {
|
|
use rustc_hex::FromHex;
|
|
use std::{str::FromStr, sync::Arc};
|
|
|
|
use futures::{Future, IntoFuture};
|
|
|
|
use super::{guess_mime_type, *};
|
|
use bytes::{Bytes, ToPretty};
|
|
use ethereum_types::Address;
|
|
use parking_lot::Mutex;
|
|
|
|
pub struct FakeRegistrar {
|
|
pub calls: Arc<Mutex<Vec<(String, String)>>>,
|
|
pub responses: Mutex<Vec<Result<Bytes, String>>>,
|
|
}
|
|
|
|
pub const REGISTRAR: &'static str = "8e4e9b13d4b45cb0befc93c3061b1408f67316b2";
|
|
pub const URLHINT: &'static str = "deadbeefcafe0000000000000000000000000000";
|
|
|
|
impl FakeRegistrar {
|
|
pub fn new() -> Self {
|
|
FakeRegistrar {
|
|
calls: Arc::new(Mutex::new(Vec::new())),
|
|
responses: Mutex::new(vec![
|
|
Ok(format!("000000000000000000000000{}", URLHINT)
|
|
.from_hex()
|
|
.unwrap()),
|
|
Ok(Vec::new()),
|
|
]),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl RegistrarClient for FakeRegistrar {
|
|
type Call = Asynchronous;
|
|
|
|
fn registrar_address(&self) -> Result<Address, String> {
|
|
Ok(REGISTRAR.parse().unwrap())
|
|
}
|
|
|
|
fn call_contract(&self, address: Address, data: Bytes) -> Self::Call {
|
|
self.calls.lock().push((address.to_hex(), data.to_hex()));
|
|
let res = self.responses.lock().remove(0);
|
|
Box::new(res.into_future())
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn should_call_registrar_and_urlhint_contracts() {
|
|
// given
|
|
let registrar = FakeRegistrar::new();
|
|
let resolve_result = {
|
|
use ethabi::{encode, Token};
|
|
encode(&[
|
|
Token::String(String::new()),
|
|
Token::FixedBytes(vec![0; 20]),
|
|
Token::Address([0; 20].into()),
|
|
])
|
|
};
|
|
registrar.responses.lock()[1] = Ok(resolve_result);
|
|
|
|
let calls = registrar.calls.clone();
|
|
let urlhint = URLHintContract::new(Arc::new(registrar));
|
|
|
|
// when
|
|
let res = urlhint.resolve("test".as_bytes().into()).wait().unwrap();
|
|
let calls = calls.lock();
|
|
let call0 = calls.get(0).expect("Registrar resolve called");
|
|
let call1 = calls.get(1).expect("URLHint Resolve called");
|
|
|
|
// then
|
|
assert!(res.is_none());
|
|
assert_eq!(call0.0, REGISTRAR);
|
|
assert_eq!(call0.1,
|
|
"6795dbcd058740ee9a5a3fb9f1cfa10752baec87e09cc45cd7027fd54708271aca300c75000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000014100000000000000000000000000000000000000000000000000000000000000".to_owned()
|
|
);
|
|
assert_eq!(call1.0, URLHINT);
|
|
assert_eq!(
|
|
call1.1,
|
|
"267b69227465737400000000000000000000000000000000000000000000000000000000".to_owned()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn should_decode_urlhint_output() {
|
|
// given
|
|
let mut registrar = FakeRegistrar::new();
|
|
registrar.responses = Mutex::new(vec![
|
|
Ok(format!("000000000000000000000000{}", URLHINT).from_hex().unwrap()),
|
|
Ok("0000000000000000000000000000000000000000000000000000000000000060ec4c1fe06c808fe3739858c347109b1f5f1ed4b5000000000000000000000000000000000000000000000000deadcafebeefbeefcafedeaddeedfeedffffffff0000000000000000000000000000000000000000000000000000000000000011657468636f72652f64616f2e636c61696d000000000000000000000000000000".from_hex().unwrap()),
|
|
]);
|
|
let urlhint = URLHintContract::new(Arc::new(registrar));
|
|
|
|
// when
|
|
let res = urlhint.resolve("test".as_bytes().into()).wait().unwrap();
|
|
|
|
// then
|
|
assert_eq!(
|
|
res,
|
|
Some(URLHintResult::Dapp(GithubApp {
|
|
account: "ethcore".into(),
|
|
repo: "dao.claim".into(),
|
|
commit: GithubApp::commit(
|
|
&"ec4c1fe06c808fe3739858c347109b1f5f1ed4b5"
|
|
.from_hex()
|
|
.unwrap()
|
|
)
|
|
.unwrap(),
|
|
owner: Address::from_str("deadcafebeefbeefcafedeaddeedfeedffffffff").unwrap(),
|
|
}))
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn should_decode_urlhint_content_output() {
|
|
// given
|
|
let mut registrar = FakeRegistrar::new();
|
|
registrar.responses = Mutex::new(vec![
|
|
Ok(format!("000000000000000000000000{}", URLHINT).from_hex().unwrap()),
|
|
Ok("00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000deadcafebeefbeefcafedeaddeedfeedffffffff000000000000000000000000000000000000000000000000000000000000003c68747470733a2f2f7061726974792e696f2f6173736574732f696d616765732f657468636f72652d626c61636b2d686f72697a6f6e74616c2e706e6700000000".from_hex().unwrap()),
|
|
]);
|
|
let urlhint = URLHintContract::new(Arc::new(registrar));
|
|
|
|
// when
|
|
let res = urlhint.resolve("test".as_bytes().into()).wait().unwrap();
|
|
|
|
// then
|
|
assert_eq!(
|
|
res,
|
|
Some(URLHintResult::Content(Content {
|
|
url: "https://parity.io/assets/images/ethcore-black-horizontal.png".into(),
|
|
mime: mime::IMAGE_PNG,
|
|
owner: Address::from_str("deadcafebeefbeefcafedeaddeedfeedffffffff").unwrap(),
|
|
}))
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn should_return_valid_url() {
|
|
// given
|
|
let app = GithubApp {
|
|
account: "test".into(),
|
|
repo: "xyz".into(),
|
|
commit: [
|
|
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
|
|
],
|
|
owner: Address::default(),
|
|
};
|
|
|
|
// when
|
|
let url = app.url();
|
|
|
|
// then
|
|
assert_eq!(
|
|
url,
|
|
"https://codeload.github.com/test/xyz/zip/000102030405060708090a0b0c0d0e0f10111213"
|
|
.to_owned()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn should_guess_mime_type_from_url() {
|
|
let url1 = "https://parity.io/parity";
|
|
let url2 = "https://parity.io/parity#content-type=image/png";
|
|
let url3 = "https://parity.io/parity#something&content-type=image/png";
|
|
let url4 = "https://parity.io/parity.png#content-type=image/jpeg";
|
|
let url5 = "https://parity.io/parity.png";
|
|
|
|
assert_eq!(guess_mime_type(url1), None);
|
|
assert_eq!(guess_mime_type(url2), Some(mime::IMAGE_PNG));
|
|
assert_eq!(guess_mime_type(url3), Some(mime::IMAGE_PNG));
|
|
assert_eq!(guess_mime_type(url4), Some(mime::IMAGE_JPEG));
|
|
assert_eq!(guess_mime_type(url5), Some(mime::IMAGE_PNG));
|
|
}
|
|
}
|