2021-09-29 01:03:47 +00:00
|
|
|
use std::collections::HashMap;
|
2021-04-09 00:22:17 +00:00
|
|
|
use std::convert::TryInto;
|
|
|
|
|
2021-09-29 01:03:47 +00:00
|
|
|
use chrono::{DateTime, Utc};
|
|
|
|
use uuid::Uuid;
|
2021-04-09 00:22:17 +00:00
|
|
|
use web3::{
|
|
|
|
api::Web3,
|
|
|
|
contract::{Contract, Options},
|
2022-01-26 13:01:05 +00:00
|
|
|
ethabi::{Event, EventParam, ParamType, RawLog, token::Token},
|
2021-04-09 00:22:17 +00:00
|
|
|
transports::Http,
|
2022-01-26 13:01:05 +00:00
|
|
|
types::{BlockNumber, FilterBuilder, H256},
|
2021-04-09 00:22:17 +00:00
|
|
|
};
|
|
|
|
|
2022-01-25 22:17:28 +00:00
|
|
|
use crate::config::BlockchainConfig;
|
2021-04-09 00:22:17 +00:00
|
|
|
use crate::database::{Pool, get_database_client};
|
|
|
|
use crate::errors::DatabaseError;
|
|
|
|
use crate::ipfs::utils::parse_ipfs_url;
|
|
|
|
use crate::models::posts::queries::{
|
|
|
|
get_post_by_ipfs_cid,
|
|
|
|
update_post,
|
2021-09-29 01:03:47 +00:00
|
|
|
get_token_waitlist,
|
2021-04-09 00:22:17 +00:00
|
|
|
};
|
|
|
|
use super::api::connect;
|
2021-10-21 16:51:01 +00:00
|
|
|
use super::contracts::{MANAGER, COLLECTIBLE, load_abi};
|
|
|
|
use super::errors::EthereumError;
|
2022-01-26 13:01:05 +00:00
|
|
|
use super::signatures::{sign_contract_call, CallArgs, SignatureData};
|
|
|
|
use super::utils::parse_address;
|
2021-04-09 00:22:17 +00:00
|
|
|
|
2021-09-29 01:03:47 +00:00
|
|
|
const TOKEN_WAIT_TIME: i64 = 10; // in minutes
|
2021-04-09 00:22:17 +00:00
|
|
|
|
|
|
|
pub async fn get_nft_contract(
|
2022-01-25 22:17:28 +00:00
|
|
|
config: &BlockchainConfig,
|
2021-04-09 00:22:17 +00:00
|
|
|
) -> Result<(Web3<Http>, Contract<Http>), EthereumError> {
|
2022-01-25 22:17:28 +00:00
|
|
|
let web3 = connect(&config.api_url)?;
|
|
|
|
let manager_abi = load_abi(&config.contract_dir, MANAGER)?;
|
|
|
|
let manager_address = parse_address(&config.contract_address)?;
|
2021-10-21 11:54:24 +00:00
|
|
|
let manager = Contract::from_json(
|
2021-04-09 00:22:17 +00:00
|
|
|
web3.eth(),
|
2021-10-21 11:54:24 +00:00
|
|
|
manager_address,
|
|
|
|
&manager_abi,
|
2021-04-09 00:22:17 +00:00
|
|
|
)?;
|
|
|
|
|
2021-10-21 11:54:24 +00:00
|
|
|
let token_address = manager.query(
|
|
|
|
"collectible",
|
|
|
|
(), None, Options::default(), None,
|
|
|
|
).await?;
|
2022-01-25 22:17:28 +00:00
|
|
|
let token_abi = load_abi(&config.contract_dir, COLLECTIBLE)?;
|
2021-04-09 00:22:17 +00:00
|
|
|
let token = Contract::from_json(
|
|
|
|
web3.eth(),
|
|
|
|
token_address,
|
|
|
|
&token_abi,
|
|
|
|
)?;
|
|
|
|
log::info!("NFT contract address is {:?}", token.address());
|
|
|
|
Ok((web3, token))
|
|
|
|
}
|
|
|
|
|
2021-12-05 22:10:35 +00:00
|
|
|
#[allow(dead_code)]
|
2021-04-09 00:22:17 +00:00
|
|
|
#[derive(Debug)]
|
|
|
|
struct TokenTransfer {
|
|
|
|
tx_id: Option<H256>,
|
|
|
|
from: Token,
|
|
|
|
to: Token,
|
|
|
|
token_id: Token,
|
|
|
|
}
|
|
|
|
|
2021-12-03 18:52:34 +00:00
|
|
|
/// Finds posts awaiting tokenization
|
|
|
|
/// and looks for corresponding Mint events
|
2021-04-09 00:22:17 +00:00
|
|
|
pub async fn process_events(
|
|
|
|
web3: &Web3<Http>,
|
|
|
|
contract: &Contract<Http>,
|
|
|
|
db_pool: &Pool,
|
2021-09-29 01:03:47 +00:00
|
|
|
token_waitlist_map: &mut HashMap<Uuid, DateTime<Utc>>,
|
2021-04-09 00:22:17 +00:00
|
|
|
) -> Result<(), EthereumError> {
|
2021-11-13 17:37:31 +00:00
|
|
|
let db_client = &**get_database_client(db_pool).await?;
|
2021-09-29 01:03:47 +00:00
|
|
|
|
|
|
|
// Create/update token waitlist map
|
|
|
|
let token_waitlist = get_token_waitlist(db_client).await?;
|
|
|
|
for post_id in token_waitlist {
|
|
|
|
if !token_waitlist_map.contains_key(&post_id) {
|
|
|
|
token_waitlist_map.insert(post_id, Utc::now());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
let token_waitlist_active_count = token_waitlist_map.values()
|
|
|
|
.filter(|waiting_since| {
|
|
|
|
let duration = Utc::now() - **waiting_since;
|
|
|
|
duration.num_minutes() < TOKEN_WAIT_TIME
|
|
|
|
})
|
|
|
|
.count();
|
|
|
|
if token_waitlist_active_count == 0 {
|
|
|
|
return Ok(())
|
2021-04-09 00:22:17 +00:00
|
|
|
}
|
2021-09-29 01:03:47 +00:00
|
|
|
log::info!(
|
2021-12-03 18:52:34 +00:00
|
|
|
"{} posts are waiting for confirmation of tokenization tx",
|
2021-09-29 01:03:47 +00:00
|
|
|
token_waitlist_active_count,
|
|
|
|
);
|
2021-04-09 00:22:17 +00:00
|
|
|
|
|
|
|
// Search for Transfer events
|
|
|
|
let event_abi_params = vec![
|
|
|
|
EventParam {
|
|
|
|
name: "from".to_string(),
|
|
|
|
kind: ParamType::Address,
|
|
|
|
indexed: true,
|
|
|
|
},
|
|
|
|
EventParam {
|
|
|
|
name: "to".to_string(),
|
|
|
|
kind: ParamType::Address,
|
|
|
|
indexed: true,
|
|
|
|
},
|
|
|
|
EventParam {
|
|
|
|
name: "tokenId".to_string(),
|
|
|
|
kind: ParamType::Uint(256),
|
|
|
|
indexed: true,
|
|
|
|
},
|
|
|
|
];
|
|
|
|
let event_abi = Event {
|
|
|
|
name: "Transfer".to_string(),
|
|
|
|
inputs: event_abi_params,
|
|
|
|
anonymous: false,
|
|
|
|
};
|
|
|
|
let filter = FilterBuilder::default()
|
|
|
|
.address(vec![contract.address()])
|
|
|
|
.topics(Some(vec![event_abi.signature()]), None, None, None)
|
|
|
|
.from_block(BlockNumber::Earliest)
|
|
|
|
.build();
|
|
|
|
let logs = web3.eth().logs(filter).await?;
|
|
|
|
|
|
|
|
// Convert web3 logs into ethabi logs
|
|
|
|
let transfers: Vec<TokenTransfer> = logs.iter().map(|log| {
|
|
|
|
let raw_log = RawLog {
|
|
|
|
topics: log.topics.clone(),
|
|
|
|
data: log.data.clone().0,
|
|
|
|
};
|
|
|
|
match event_abi.parse_log(raw_log) {
|
|
|
|
Ok(event) => {
|
|
|
|
let params = event.params;
|
|
|
|
let transfer = TokenTransfer {
|
|
|
|
tx_id: log.transaction_hash,
|
|
|
|
from: params[0].value.clone(),
|
|
|
|
to: params[1].value.clone(),
|
|
|
|
token_id: params[2].value.clone(),
|
|
|
|
};
|
|
|
|
Ok(transfer)
|
|
|
|
},
|
|
|
|
Err(err) => Err(err),
|
|
|
|
}
|
|
|
|
}).collect::<Result<_, web3::ethabi::Error>>()?;
|
|
|
|
for transfer in transfers {
|
|
|
|
let from_address = transfer.from.into_address()
|
|
|
|
.ok_or(EthereumError::ConversionError)?;
|
|
|
|
if from_address.is_zero() {
|
|
|
|
// Mint event found
|
|
|
|
let token_id_u256 = transfer.token_id.into_uint()
|
|
|
|
.ok_or(EthereumError::ConversionError)?;
|
2021-10-21 11:54:24 +00:00
|
|
|
let token_uri: String = contract.query(
|
|
|
|
"tokenURI", (token_id_u256,),
|
|
|
|
None, Options::default(), None,
|
|
|
|
).await?;
|
2021-04-09 00:22:17 +00:00
|
|
|
let tx_id_h256 = transfer.tx_id.ok_or(EthereumError::ConversionError)?;
|
|
|
|
let tx_id = hex::encode(tx_id_h256.as_bytes());
|
|
|
|
let ipfs_cid = parse_ipfs_url(&token_uri)
|
|
|
|
.map_err(|_| EthereumError::TokenUriParsingError)?;
|
|
|
|
let mut post = match get_post_by_ipfs_cid(db_client, &ipfs_cid).await {
|
|
|
|
Ok(post) => post,
|
2021-09-29 01:03:47 +00:00
|
|
|
Err(DatabaseError::NotFound(_)) => {
|
|
|
|
// Post was deleted
|
|
|
|
continue;
|
|
|
|
},
|
2021-04-09 00:22:17 +00:00
|
|
|
Err(err) => {
|
2021-09-29 01:03:47 +00:00
|
|
|
// Unexpected error
|
2021-04-09 00:22:17 +00:00
|
|
|
log::error!("{}", err);
|
|
|
|
continue;
|
|
|
|
},
|
|
|
|
};
|
|
|
|
if post.token_id.is_none() {
|
|
|
|
log::info!("post {} was tokenized via {}", post.id, tx_id);
|
|
|
|
let token_id: i32 = token_id_u256.try_into()
|
|
|
|
.map_err(|_| EthereumError::ConversionError)?;
|
|
|
|
post.token_id = Some(token_id);
|
|
|
|
post.token_tx_id = Some(tx_id);
|
|
|
|
update_post(db_client, &post).await?;
|
2021-09-29 01:03:47 +00:00
|
|
|
token_waitlist_map.remove(&post.id);
|
2021-04-09 00:22:17 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn create_mint_signature(
|
2022-01-25 22:17:28 +00:00
|
|
|
blockchain_config: &BlockchainConfig,
|
2021-04-09 00:22:17 +00:00
|
|
|
user_address: &str,
|
|
|
|
token_uri: &str,
|
|
|
|
) -> Result<SignatureData, EthereumError> {
|
|
|
|
let user_address = parse_address(user_address)?;
|
2022-01-26 13:01:05 +00:00
|
|
|
let call_args: CallArgs = vec![
|
|
|
|
Box::new(user_address),
|
|
|
|
Box::new(token_uri.to_string()),
|
|
|
|
];
|
|
|
|
let signature = sign_contract_call(
|
|
|
|
&blockchain_config.signing_key,
|
|
|
|
blockchain_config.ethereum_chain_id(),
|
|
|
|
&blockchain_config.contract_address,
|
|
|
|
"mint",
|
|
|
|
call_args,
|
|
|
|
)?;
|
2021-04-09 00:22:17 +00:00
|
|
|
Ok(signature)
|
|
|
|
}
|