> + Send + 'a>, Error>;
async fn wait_for_transaction_metadata(
@@ -127,35 +124,32 @@ pub trait BitcoinCoreApi {
async fn wallet_has_public_key(&self, public_key: P) -> Result
where
- P: Into<[u8; PUBLIC_KEY_SIZE]>
- + From<[u8; PUBLIC_KEY_SIZE]>
- + Clone
- + PartialEq
- + Send
- + Sync
- + 'static;
+ P: Into<[u8; PUBLIC_KEY_SIZE]> + From<[u8; PUBLIC_KEY_SIZE]> + Clone + PartialEq + Send + Sync + 'static;
}
pub struct LockedTransaction {
pub transaction: Transaction,
- _lock: OwnedMutexGuard<()>,
+ _lock: Option>,
}
+
impl LockedTransaction {
- pub fn new(transaction: Transaction, lock: OwnedMutexGuard<()>) -> Self {
+ pub fn new(transaction: Transaction, lock: Option>) -> Self {
LockedTransaction {
transaction,
_lock: lock,
}
}
}
+
+#[derive(Clone)]
pub struct BitcoinCore {
- rpc: Client,
+ rpc: Arc,
transaction_creation_lock: Arc>,
network: Network,
}
impl BitcoinCore {
- pub fn new(rpc: Client, network: Network) -> Self {
+ pub fn new(rpc: Arc, network: Network) -> Self {
Self {
rpc,
network,
@@ -163,6 +157,67 @@ impl BitcoinCore {
}
}
+ pub async fn new_with_retry(
+ rpc: Arc,
+ network: Network,
+ connection_timeout: Duration,
+ ) -> Result {
+ let core = Self::new(rpc, network);
+ core.connect(connection_timeout).await?;
+ core.sync().await?;
+ Ok(core)
+ }
+
+ /// Connect to a bitcoin-core full node or timeout.
+ ///
+ /// # Arguments
+ /// * `connection_timeout` - maximum duration before elapsing
+ async fn connect(&self, connection_timeout: Duration) -> Result<(), Error> {
+ info!("Connecting to bitcoin-core...");
+ timeout(connection_timeout, async move {
+ loop {
+ match self.rpc.get_blockchain_info() {
+ Err(BitcoinError::JsonRpc(JsonRpcError::Hyper(HyperError::Io(err))))
+ if err.kind() == IoErrorKind::ConnectionRefused =>
+ {
+ trace!("could not connect to bitcoin-core");
+ delay_for(RETRY_DURATION).await;
+ continue;
+ }
+ Err(BitcoinError::JsonRpc(JsonRpcError::Rpc(err)))
+ if BitcoinRpcError::from(err.clone()) == BitcoinRpcError::RpcInWarmup =>
+ {
+ // may be loading block index or verifying wallet
+ trace!("bitcoin-core still in warm up");
+ delay_for(RETRY_DURATION).await;
+ continue;
+ }
+ Ok(_) => {
+ info!("Connected!");
+ return Ok(());
+ }
+ Err(err) => return Err(err.into()),
+ }
+ }
+ })
+ .await?
+ }
+
+ /// Wait indefinitely for the node to sync.
+ async fn sync(&self) -> Result<(), Error> {
+ info!("Waiting for bitcoin-core to sync...");
+ loop {
+ let info = self.rpc.get_blockchain_info()?;
+ // NOTE: initial_block_download is always true on regtest
+ if !info.initial_block_download || info.verification_progress == 1.0 {
+ info!("Synced!");
+ return Ok(());
+ }
+ trace!("bitcoin-core not synced");
+ delay_for(RETRY_DURATION).await;
+ }
+ }
+
/// Wrapper of rust_bitcoincore_rpc::create_raw_transaction_hex that accepts an optional op_return
fn create_raw_transaction_hex(
&self,
@@ -176,10 +231,7 @@ impl BitcoinCore {
if let Some(request_id) = request_id {
// add the op_return data - bitcoind will add op_return and the length automatically
- outputs.insert(
- "data".to_string(),
- serde_json::Value::from(request_id.to_hex()),
- );
+ outputs.insert("data".to_string(), serde_json::Value::from(request_id.to_hex()));
}
let args = [
@@ -191,10 +243,8 @@ impl BitcoinCore {
#[cfg(feature = "regtest-manual-mining")]
pub fn mine_block(&self) -> Result<(), Error> {
- self.rpc.generate_to_address(
- 1,
- &self.rpc.get_new_address(None, Some(AddressType::Bech32))?,
- )?;
+ self.rpc
+ .generate_to_address(1, &self.rpc.get_new_address(None, Some(AddressType::Bech32))?)?;
Ok(())
}
}
@@ -218,12 +268,7 @@ impl BitcoinCoreApi for BitcoinCore {
/// # Arguments
/// * `height` - block height to fetch
/// * `delay` - wait period before re-checking
- async fn wait_for_block(
- &self,
- height: u32,
- delay: Duration,
- num_confirmations: u32,
- ) -> Result {
+ async fn wait_for_block(&self, height: u32, delay: Duration, num_confirmations: u32) -> Result {
loop {
match self.rpc.get_block_hash(height.into()) {
Ok(hash) => {
@@ -264,9 +309,7 @@ impl BitcoinCoreApi for BitcoinCore {
/// * `txid` - transaction ID
/// * `block_hash` - hash of the block tx is stored in
async fn get_raw_tx_for(&self, txid: &Txid, block_hash: &BlockHash) -> Result, Error> {
- Ok(serialize(
- &self.rpc.get_raw_transaction(txid, Some(block_hash))?,
- ))
+ Ok(serialize(&self.rpc.get_raw_transaction(txid, Some(block_hash))?))
}
/// Get the merkle proof which can be used to validate transaction inclusion.
@@ -282,20 +325,18 @@ impl BitcoinCoreApi for BitcoinCore {
///
/// # Arguments
/// * `height` - block height
- async fn get_block_hash_for(&self, height: u32) -> Result {
+ async fn get_block_hash(&self, height: u32) -> Result {
match self.rpc.get_block_hash(height.into()) {
Ok(block_hash) => Ok(block_hash),
- Err(e) => Err(
- if let BitcoinError::JsonRpc(JsonRpcError::Rpc(rpc_error)) = &e {
- match BitcoinRpcError::from(rpc_error.clone()) {
- // block does not exist yet
- BitcoinRpcError::RpcInvalidParameter => Error::InvalidBitcoinHeight,
- _ => e.into(),
- }
- } else {
- e.into()
- },
- ),
+ Err(e) => Err(if let BitcoinError::JsonRpc(JsonRpcError::Rpc(rpc_error)) = &e {
+ match BitcoinRpcError::from(rpc_error.clone()) {
+ // block does not exist yet
+ BitcoinRpcError::RpcInvalidParameter => Error::InvalidBitcoinHeight,
+ _ => e.into(),
+ }
+ } else {
+ e.into()
+ }),
}
}
@@ -322,9 +363,7 @@ impl BitcoinCoreApi for BitcoinCore {
}
/// Gets a new public key for an address in the wallet
- async fn get_new_public_key + 'static>(
- &self,
- ) -> Result {
+ async fn get_new_public_key + 'static>(&self) -> Result {
let address = self.rpc.get_new_address(None, Some(AddressType::Bech32))?;
let address_info = self.rpc.get_address_info(&address)?;
let public_key = address_info.pubkey.ok_or(Error::MissingPublicKey)?;
@@ -340,10 +379,8 @@ impl BitcoinCoreApi for BitcoinCore {
let address = Address::p2wpkh(&PublicKey::from_slice(&public_key.into())?, self.network)
.map_err(|err| ConversionError::from(err))?;
let private_key = self.rpc.dump_private_key(&address)?;
- let deposit_secret_key = addr::calculate_deposit_secret_key(
- private_key.key,
- SecretKey::from_slice(&secret_key)?,
- )?;
+ let deposit_secret_key =
+ addr::calculate_deposit_secret_key(private_key.key, SecretKey::from_slice(&secret_key)?)?;
self.rpc.import_private_key(
&PrivateKey {
compressed: private_key.compressed,
@@ -365,6 +402,10 @@ impl BitcoinCoreApi for BitcoinCore {
Ok(self.rpc.get_block(hash)?)
}
+ async fn get_block_header(&self, hash: &BlockHash) -> Result {
+ Ok(self.rpc.get_block_header(hash)?)
+ }
+
async fn get_block_info(&self, hash: &BlockHash) -> Result {
Ok(self.rpc.get_block_info(hash)?)
}
@@ -372,7 +413,7 @@ impl BitcoinCoreApi for BitcoinCore {
/// Get the transactions that are currently in the mempool. Since `impl trait` is not
/// allowed within trait method, we have to use trait objects.
async fn get_mempool_transactions<'a>(
- self: Arc,
+ self: &'a Self,
) -> Result> + Send + 'a>, Error> {
// get txids from the mempool
let txids = self.rpc.get_raw_mempool()?;
@@ -386,6 +427,7 @@ impl BitcoinCoreApi for BitcoinCore {
});
Ok(Box::new(iterator))
}
+
/// Waits for the required number of confirmations, and collects data about the
/// transaction
///
@@ -421,9 +463,7 @@ impl BitcoinCoreApi for BitcoinCore {
..
},
..
- }) if confirmations >= 0 && confirmations as u32 >= num_confirmations => {
- Ok((height, hash))
- }
+ }) if confirmations >= 0 && confirmations as u32 >= num_confirmations => Ok((height, hash)),
Ok(_) => Err(Error::ConfirmationError),
Err(e) => Err(e.into()),
}?)
@@ -468,8 +508,7 @@ impl BitcoinCoreApi for BitcoinCore {
// this function would be to call create_raw_transaction (without the _hex suffix), and
// to add the op_return afterwards. However, this function fails if no inputs are
// specified, as is the case for us prior to calling fund_raw_transaction.
- let raw_tx =
- self.create_raw_transaction_hex(address_string, Amount::from_sat(sat), request_id)?;
+ let raw_tx = self.create_raw_transaction_hex(address_string, Amount::from_sat(sat), request_id)?;
// ensure no other fund_raw_transaction calls are made until we submitted the
// transaction to the bitcoind. If we don't do this, the same uxto may be used
@@ -491,7 +530,7 @@ impl BitcoinCoreApi for BitcoinCore {
let transaction = signed_funded_raw_tx.transaction()?;
- Ok(LockedTransaction::new(transaction, lock))
+ Ok(LockedTransaction::new(transaction, Some(lock)))
}
/// Submits a transaction to the mempool
@@ -540,15 +579,11 @@ impl BitcoinCoreApi for BitcoinCore {
op_timeout: Duration,
num_confirmations: u32,
) -> Result {
- let txid = self
- .create_and_send_transaction(address, sat, request_id)
- .await?;
+ let txid = self.create_and_send_transaction(address, sat, request_id).await?;
#[cfg(feature = "regtest-mine-on-tx")]
- self.rpc.generate_to_address(
- 1,
- &self.rpc.get_new_address(None, Some(AddressType::Bech32))?,
- )?;
+ self.rpc
+ .generate_to_address(1, &self.rpc.get_new_address(None, Some(AddressType::Bech32))?)?;
Ok(self
.wait_for_transaction_metadata(txid, op_timeout, num_confirmations)
@@ -575,19 +610,10 @@ impl BitcoinCoreApi for BitcoinCore {
async fn wallet_has_public_key(&self, public_key: P) -> Result
where
- P: Into<[u8; PUBLIC_KEY_SIZE]>
- + From<[u8; PUBLIC_KEY_SIZE]>
- + Clone
- + PartialEq
- + Send
- + Sync
- + 'static,
+ P: Into<[u8; PUBLIC_KEY_SIZE]> + From<[u8; PUBLIC_KEY_SIZE]> + Clone + PartialEq + Send + Sync + 'static,
{
- let address = Address::p2wpkh(
- &PublicKey::from_slice(&public_key.clone().into())?,
- self.network,
- )
- .map_err(|err| ConversionError::from(err))?;
+ let address = Address::p2wpkh(&PublicKey::from_slice(&public_key.clone().into())?, self.network)
+ .map_err(|err| ConversionError::from(err))?;
let address_info = self.rpc.get_address_info(&address)?;
let wallet_pubkey = address_info.pubkey.ok_or(Error::MissingPublicKey)?;
Ok(P::from(wallet_pubkey.key.serialize()) == public_key)
@@ -651,7 +677,7 @@ impl TransactionExt for Transaction {
}
}
-// https://gitlab.com/interlay/btc-parachain/-/blob/dev/crates/bitcoin/src/parser.rs#L264
+// https://github.com/interlay/btc-parachain/blob/cc5c16b28ef705e0774654dd94b813d9d35e12ec/crates/bitcoin/src/parser.rs#L277
fn parse_compact_uint(varint: &[u8]) -> Result<(u64, usize), Error> {
match varint.get(0).ok_or(Error::ParsingError)? {
0xfd => {
@@ -693,15 +719,13 @@ fn vin_to_address(vin: TxIn) -> Result {
// TODO: reuse logic from bitcoin crate
let last = std::cmp::min(pos + 3, input_script.len());
- let (size, len) =
- parse_compact_uint(input_script.get(pos..last).ok_or(Error::ParsingError)?)?;
+ let (size, len) = parse_compact_uint(input_script.get(pos..last).ok_or(Error::ParsingError)?)?;
pos += len;
// skip sigs
pos += size as usize;
// parse redeem_script or compressed public_key
let last = std::cmp::min(pos + 3, input_script.len());
- let (_size, len) =
- parse_compact_uint(input_script.get(pos..last).ok_or(Error::ParsingError)?)?;
+ let (_size, len) = parse_compact_uint(input_script.get(pos..last).ok_or(Error::ParsingError)?)?;
pos += len;
let bytes = input_script.get(pos..).ok_or(Error::ParsingError)?;
diff --git a/faucet/Cargo.toml b/faucet/Cargo.toml
index 6d7db40a0..da693bcdf 100644
--- a/faucet/Cargo.toml
+++ b/faucet/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "faucet"
-version = "0.2.0"
+version = "0.5.0"
authors = ["Interlay "]
edition = "2018"
@@ -10,26 +10,22 @@ env_logger = "0.6.1"
clap = "3.0.0-beta.2"
chrono = "0.4.19"
tokio = { version = "0.2.22", features = ["full"] }
-runtime = { path = "../runtime" }
-bitcoin = { path = "../bitcoin", features = ["cli"] }
thiserror = "1.0"
-jsonrpc-http-server = "16.0.0"
-jsonrpsee = "0.1.0"
+jsonrpc-http-server = "17.0.0"
parity-scale-codec = "2.0.0"
serde_json = "1.0.57"
serde = "1.0.116"
-futures = "0.3.5"
hex = "0.4.2"
kv = { version = "0.22.0", features = ["json-value"] }
-pin-project-lite = "0.2.4"
+async-trait = "0.1.40"
-# Substrate dependencies
-sp-core = { git = "https://github.com/paritytech/substrate", branch = "rococo-v1" }
-sp-keyring = { git = "https://github.com/paritytech/substrate", branch = "rococo-v1" }
+# Workspace dependencies
+runtime = { path = "../runtime" }
[dev-dependencies]
-substrate-subxt-client = { git = "https://github.com/interlay/substrate-subxt", rev = "9ef6ed9" }
-tempdir = "0.3.7"
-btc-parachain = { git = "https://gitlab.com/interlay/btc-parachain", branch = "dev", version = "0.5.0", features = ["aura-grandpa"] }
-btc-parachain-service = { git = "https://gitlab.com/interlay/btc-parachain", branch = "dev", version = "0.5.0", features = ["aura-grandpa"] }
+# Workspace dependencies
+runtime = { path = "../runtime", features = ["testing-utils"] }
+
+# Substrate dependencies
+sp-keyring = { git = "https://github.com/paritytech/substrate", branch = "rococo-v1" }
diff --git a/faucet/src/http.rs b/faucet/src/http.rs
index 99a295969..fee024a41 100644
--- a/faucet/src/http.rs
+++ b/faucet/src/http.rs
@@ -1,21 +1,22 @@
use crate::Error;
-use chrono::{DateTime, Duration, Utc};
-use futures::{self, executor::block_on};
+use chrono::{DateTime, Duration as ISO8601, Utc};
use hex::FromHex;
-use jsonrpc_http_server::jsonrpc_core::serde_json::Value;
-use jsonrpc_http_server::jsonrpc_core::{Error as JsonRpcError, ErrorCode as JsonRpcErrorCode};
-use jsonrpc_http_server::jsonrpc_core::{IoHandler, Params};
-use jsonrpc_http_server::{DomainsValidation, ServerBuilder};
+use jsonrpc_http_server::{
+ jsonrpc_core::{serde_json::Value, Error as JsonRpcError, ErrorCode as JsonRpcErrorCode, IoHandler, Params},
+ DomainsValidation, ServerBuilder,
+};
use kv::*;
-use log::error;
+use log::{debug, info, warn};
use parity_scale_codec::{Decode, Encode};
use runtime::{
- AccountId, DotBalancesPallet, PolkaBtcProvider, SecurityPallet, StakedRelayerPallet,
- VaultRegistryPallet, PLANCK_PER_DOT,
+ AccountId, DotBalancesPallet, Error as RuntimeError, PolkaBtcProvider, StakedRelayerPallet, VaultRegistryPallet,
+ PLANCK_PER_DOT,
};
use serde::{Deserialize, Deserializer};
-use std::sync::Arc;
-use std::{collections::HashMap, net::SocketAddr};
+use std::{collections::HashMap, net::SocketAddr, time::Duration};
+use tokio::time::timeout;
+
+const HEALTH_DURATION: Duration = Duration::from_millis(5000);
const KV_STORE_NAME: &str = "store";
const FAUCET_COOLDOWN_HOURS: i64 = 6;
@@ -26,6 +27,18 @@ struct FaucetRequest {
account_type: FundingRequestAccountType,
}
+#[derive(Debug, Clone, Deserialize)]
+struct RawBytes(#[serde(deserialize_with = "hex_to_buffer")] Vec);
+
+pub fn hex_to_buffer<'de, D>(deserializer: D) -> Result, D::Error>
+where
+ D: Deserializer<'de>,
+{
+ use serde::de::Error;
+ String::deserialize(deserializer)
+ .and_then(|string| Vec::from_hex(&string[2..]).map_err(|err| Error::custom(err.to_string())))
+}
+
fn parse_params(params: Params) -> Result {
let raw: [RawBytes; 1] = params.parse()?;
let req = Decode::decode(&mut &raw[0].0[..]).map_err(Error::CodecError)?;
@@ -43,22 +56,11 @@ fn handle_resp(resp: Result) -> Result
}
}
-#[derive(Debug, Clone, Deserialize)]
-struct RawBytes(#[serde(deserialize_with = "hex_to_buffer")] Vec);
-
-pub fn hex_to_buffer<'de, D>(deserializer: D) -> Result, D::Error>
-where
- D: Deserializer<'de>,
-{
- use serde::de::Error;
- String::deserialize(deserializer).and_then(|string| {
- Vec::from_hex(&string[2..]).map_err(|err| Error::custom(err.to_string()))
- })
-}
-
-fn _system_health(provider: &Arc) -> Result<(), Error> {
- block_on(provider.get_parachain_status())?;
- Ok(())
+async fn _system_health(provider: &PolkaBtcProvider) -> Result<(), Error> {
+ match timeout(HEALTH_DURATION, provider.get_latest_block_hash()).await {
+ Err(err) => Err(Error::RuntimeError(RuntimeError::from(err))),
+ _ => Ok(()),
+ }
}
#[derive(Encode, Decode, Debug, Clone)]
@@ -74,7 +76,7 @@ enum FundingRequestAccountType {
}
async fn _fund_account_raw(
- provider: &Arc,
+ provider: &PolkaBtcProvider,
params: Params,
store: Store,
user_allowance: u128,
@@ -85,21 +87,18 @@ async fn _fund_account_raw(
let mut allowances = HashMap::new();
allowances.insert(FundingRequestAccountType::User, user_allowance);
allowances.insert(FundingRequestAccountType::Vault, vault_allowance);
- allowances.insert(
- FundingRequestAccountType::StakedRelayer,
- staked_relayer_allowance,
- );
+ allowances.insert(FundingRequestAccountType::StakedRelayer, staked_relayer_allowance);
fund_account(provider, req, store, allowances).await
}
async fn get_account_type(
- provider: &Arc,
+ provider: &PolkaBtcProvider,
account_id: AccountId,
) -> Result {
if let Ok(_) = provider.get_vault(account_id.clone()).await {
return Ok(FundingRequestAccountType::Vault);
}
- let active_stake = provider.get_stake_by_id(account_id.clone()).await?;
+ let active_stake = provider.get_active_stake_by_id(account_id.clone()).await?;
let inactive_stake = provider.get_inactive_stake_by_id(account_id).await?;
if active_stake.gt(&0) || inactive_stake.gt(&0) {
return Ok(FundingRequestAccountType::StakedRelayer);
@@ -122,7 +121,6 @@ fn update_kv_store(
account_type,
};
kv.set(account_id.to_string(), Json(faucet_request))?;
- kv.flush()?;
Ok(())
}
@@ -131,8 +129,7 @@ fn is_type_and_was_user(
current_account_type: FundingRequestAccountType,
previous_account_type: FundingRequestAccountType,
) -> bool {
- current_account_type.eq(&account_type)
- && previous_account_type.eq(&FundingRequestAccountType::User)
+ current_account_type.eq(&account_type) && previous_account_type.eq(&FundingRequestAccountType::User)
}
fn has_request_expired(
@@ -165,7 +162,7 @@ fn is_funding_allowed(
// Unless there's a bug in the std lib implementation of Utc::now() or a false reading from the
// system clock, unwrap will never panic
let cooldown_threshold = Utc::now()
- .checked_sub_signed(Duration::hours(FAUCET_COOLDOWN_HOURS))
+ .checked_sub_signed(ISO8601::hours(FAUCET_COOLDOWN_HOURS))
.ok_or(Error::MathError)?;
Ok(match last_request_json {
@@ -180,7 +177,7 @@ fn is_funding_allowed(
}
async fn atomic_faucet_funding(
- provider: &Arc,
+ provider: &PolkaBtcProvider,
kv: Bucket<'_, String, Json>,
account_id: AccountId,
allowances: HashMap,
@@ -188,70 +185,68 @@ async fn atomic_faucet_funding(
let last_request_json = kv.get(account_id.to_string())?;
let account_type = get_account_type(&provider, account_id.clone()).await?;
if !is_funding_allowed(last_request_json, account_type.clone())? {
+ warn!("{} already funded", account_id);
return Err(Error::FaucetOveruseError);
}
// Replace the previous, expired claim datetime with the datetime of the current claim
- update_kv_store(
- &kv,
- account_id.clone(),
- Utc::now().to_rfc2822(),
- account_type.clone(),
- )?;
+ update_kv_store(&kv, account_id.clone(), Utc::now().to_rfc2822(), account_type.clone())?;
let amount = allowances
.get(&account_type)
.ok_or(Error::NoFaucetAllowance)?
.checked_mul(PLANCK_PER_DOT)
.ok_or(Error::MathError)?;
+ info!(
+ "AccountId: {}, Type: {:?}, Amount: {}",
+ account_id, account_type, amount
+ );
provider.transfer_to(account_id, amount).await?;
Ok(())
}
async fn fund_account(
- provider: &Arc,
+ provider: &PolkaBtcProvider,
req: FundAccountJsonRpcRequest,
store: Store,
allowances: HashMap,
) -> Result<(), Error> {
let provider = provider.clone();
let kv = open_kv_store(store)?;
- block_on(atomic_faucet_funding(
- &provider,
- kv,
- req.account_id.clone(),
- allowances,
- ))?;
+ atomic_faucet_funding(&provider, kv, req.account_id.clone(), allowances).await?;
Ok(())
}
-pub async fn start(
- provider: Arc,
+pub async fn start_http(
+ provider: PolkaBtcProvider,
addr: SocketAddr,
origin: String,
user_allowance: u128,
vault_allowance: u128,
staked_relayer_allowance: u128,
-) {
+ handle: tokio::runtime::Handle,
+) -> jsonrpc_http_server::CloseHandle {
let mut io = IoHandler::default();
+ let store = Store::new(Config::new("./kv")).expect("Unable to open kv store");
io.add_sync_method("user_allowance", move |_| handle_resp(Ok(user_allowance)));
io.add_sync_method("vault_allowance", move |_| handle_resp(Ok(vault_allowance)));
io.add_sync_method("staked_relayer_allowance", move |_| {
handle_resp(Ok(staked_relayer_allowance))
});
- let provider = provider.clone();
{
let provider = provider.clone();
- io.add_sync_method("system_health", move |_| {
- handle_resp(_system_health(&provider))
+ io.add_method("system_health", move |_| {
+ let provider = provider.clone();
+ async move { handle_resp(_system_health(&provider).await) }
});
}
{
let provider = provider.clone();
+ let store = store.clone();
// an async closure is only FnOnce, so we need this workaround
io.add_method("fund_account", move |params| {
let provider = provider.clone();
+ let store = store.clone();
async move {
- let store = Store::new(Config::new("./kv")).expect("Unable to open kv store");
let result = _fund_account_raw(
&provider.clone(),
params,
@@ -261,23 +256,28 @@ pub async fn start(
staked_relayer_allowance,
)
.await;
+ debug!("Result: {:?}", result);
handle_resp(result)
}
});
};
let server = ServerBuilder::new(io)
+ .event_loop_executor(handle.clone())
.health_api(("/health", "system_health"))
.rest_api(jsonrpc_http_server::RestApi::Unsecure)
.cors(DomainsValidation::AllowOnly(vec![origin.into()]))
.start_http(&addr)
.expect("Unable to start RPC server");
- tokio::task::spawn_blocking(move || {
+ let close_handle = server.close_handle();
+
+ handle.spawn_blocking(move || {
+ info!("Starting http server...");
server.wait();
- })
- .await
- .unwrap();
+ });
+
+ close_handle
}
#[cfg(test)]
@@ -286,18 +286,12 @@ mod tests {
use std::{collections::HashMap, sync::Arc};
use super::{
- fund_account, open_kv_store, DotBalancesPallet, FundAccountJsonRpcRequest,
- FundingRequestAccountType, PolkaBtcProvider, PLANCK_PER_DOT,
+ fund_account, open_kv_store, DotBalancesPallet, FundAccountJsonRpcRequest, FundingRequestAccountType,
+ PLANCK_PER_DOT,
};
- use jsonrpsee::Client as JsonRpseeClient;
use kv::{Config, Store};
- use runtime::{substrate_subxt::PairSigner, StakedRelayerPallet};
- use runtime::{AccountId, BtcPublicKey, PolkaBtcRuntime, VaultRegistryPallet};
+ use runtime::{integration::*, AccountId, BtcPublicKey, StakedRelayerPallet, VaultRegistryPallet};
use sp_keyring::AccountKeyring;
- use substrate_subxt_client::{
- DatabaseConfig, KeystoreConfig, Role, SubxtClient, SubxtClientConfig,
- };
- use tempdir::TempDir;
macro_rules! assert_err {
($result:expr, $err:pat) => {{
@@ -311,43 +305,11 @@ mod tests {
fn dummy_public_key() -> BtcPublicKey {
BtcPublicKey([
- 2, 205, 114, 218, 156, 16, 235, 172, 106, 37, 18, 153, 202, 140, 176, 91, 207, 51, 187,
- 55, 18, 45, 222, 180, 119, 54, 243, 97, 173, 150, 161, 169, 230,
+ 2, 205, 114, 218, 156, 16, 235, 172, 106, 37, 18, 153, 202, 140, 176, 91, 207, 51, 187, 55, 18, 45, 222,
+ 180, 119, 54, 243, 97, 173, 150, 161, 169, 230,
])
}
- async fn default_provider_client(key: AccountKeyring) -> (JsonRpseeClient, TempDir) {
- let tmp = TempDir::new("btc-parachain-").expect("failed to create tempdir");
- let config = SubxtClientConfig {
- impl_name: "btc-parachain-full-client",
- impl_version: "0.0.1",
- author: "Interlay Ltd",
- copyright_start_year: 2020,
- db: DatabaseConfig::ParityDb {
- path: tmp.path().join("db"),
- },
- keystore: KeystoreConfig::Path {
- path: tmp.path().join("keystore"),
- password: None,
- },
- chain_spec: btc_parachain::chain_spec::development_config(),
- role: Role::Authority(key.clone()),
- telemetry: None,
- };
-
- let client = SubxtClient::from_config(config, btc_parachain_service::new_full)
- .expect("Error creating subxt client")
- .into();
- return (client, tmp);
- }
-
- async fn setup_provider(client: JsonRpseeClient, key: AccountKeyring) -> PolkaBtcProvider {
- let signer = PairSigner::::new(key.pair());
- PolkaBtcProvider::new(client, signer)
- .await
- .expect("Error creating provider")
- }
-
fn dot_to_planck(dot: u128) -> u128 {
dot.checked_mul(PLANCK_PER_DOT).unwrap()
}
@@ -363,15 +325,11 @@ mod tests {
let mut allowances: HashMap = HashMap::new();
allowances.insert(FundingRequestAccountType::User, user_allowance_dot);
allowances.insert(FundingRequestAccountType::Vault, vault_allowance_dot);
- allowances.insert(
- FundingRequestAccountType::StakedRelayer,
- staked_relayer_allowance_dot,
- );
+ allowances.insert(FundingRequestAccountType::StakedRelayer, staked_relayer_allowance_dot);
let expected_amount_planck: u128 = dot_to_planck(user_allowance_dot);
- let store =
- Store::new(Config::new(tmp_dir.path().join("kv1"))).expect("Unable to open kv store");
+ let store = Store::new(Config::new(tmp_dir.path().join("kv1"))).expect("Unable to open kv store");
let kv = open_kv_store(store.clone()).unwrap();
kv.clear().unwrap();
@@ -407,14 +365,10 @@ mod tests {
let mut allowances: HashMap = HashMap::new();
allowances.insert(FundingRequestAccountType::User, user_allowance_dot);
allowances.insert(FundingRequestAccountType::Vault, vault_allowance_dot);
- allowances.insert(
- FundingRequestAccountType::StakedRelayer,
- staked_relayer_allowance_dot,
- );
+ allowances.insert(FundingRequestAccountType::StakedRelayer, staked_relayer_allowance_dot);
let expected_amount_planck: u128 = dot_to_planck(vault_allowance_dot);
- let store =
- Store::new(Config::new(tmp_dir.path().join("kv3"))).expect("Unable to open kv store");
+ let store = Store::new(Config::new(tmp_dir.path().join("kv3"))).expect("Unable to open kv store");
let kv = open_kv_store(store.clone()).unwrap();
kv.clear().unwrap();
@@ -434,10 +388,7 @@ mod tests {
.expect("Funding the account failed");
let bob_provider = setup_provider(client.clone(), AccountKeyring::Bob).await;
- bob_provider
- .register_vault(100, dummy_public_key())
- .await
- .unwrap();
+ bob_provider.register_vault(100, dummy_public_key()).await.unwrap();
let bob_funds_before = alice_provider
.get_free_dot_balance_for_id(bob_account_id.clone())
@@ -466,14 +417,10 @@ mod tests {
let mut allowances: HashMap = HashMap::new();
allowances.insert(FundingRequestAccountType::User, user_allowance_dot);
allowances.insert(FundingRequestAccountType::Vault, vault_allowance_dot);
- allowances.insert(
- FundingRequestAccountType::StakedRelayer,
- staked_relayer_allowance_dot,
- );
+ allowances.insert(FundingRequestAccountType::StakedRelayer, staked_relayer_allowance_dot);
let expected_amount_planck: u128 = dot_to_planck(staked_relayer_allowance_dot);
- let store =
- Store::new(Config::new(tmp_dir.path().join("kv3"))).expect("Unable to open kv store");
+ let store = Store::new(Config::new(tmp_dir.path().join("kv3"))).expect("Unable to open kv store");
let kv = open_kv_store(store.clone()).unwrap();
kv.clear().unwrap();
@@ -522,14 +469,10 @@ mod tests {
let mut allowances: HashMap = HashMap::new();
allowances.insert(FundingRequestAccountType::User, user_allowance_dot);
allowances.insert(FundingRequestAccountType::Vault, vault_allowance_dot);
- allowances.insert(
- FundingRequestAccountType::StakedRelayer,
- staked_relayer_allowance_dot,
- );
+ allowances.insert(FundingRequestAccountType::StakedRelayer, staked_relayer_allowance_dot);
let expected_amount_planck: u128 = dot_to_planck(user_allowance_dot);
- let store =
- Store::new(Config::new(tmp_dir.path().join("kv3"))).expect("Unable to open kv store");
+ let store = Store::new(Config::new(tmp_dir.path().join("kv3"))).expect("Unable to open kv store");
let kv = open_kv_store(store.clone()).unwrap();
kv.clear().unwrap();
@@ -574,17 +517,11 @@ mod tests {
let mut allowances: HashMap = HashMap::new();
allowances.insert(FundingRequestAccountType::User, user_allowance_dot);
allowances.insert(FundingRequestAccountType::Vault, vault_allowance_dot);
- allowances.insert(
- FundingRequestAccountType::StakedRelayer,
- staked_relayer_allowance_dot,
- );
+ allowances.insert(FundingRequestAccountType::StakedRelayer, staked_relayer_allowance_dot);
let expected_amount_planck: u128 = dot_to_planck(vault_allowance_dot);
let bob_provider = setup_provider(client.clone(), AccountKeyring::Bob).await;
- bob_provider
- .register_vault(100, dummy_public_key())
- .await
- .unwrap();
+ bob_provider.register_vault(100, dummy_public_key()).await.unwrap();
let alice_provider = setup_provider(client.clone(), AccountKeyring::Alice).await;
let bob_funds_before = alice_provider
@@ -595,8 +532,7 @@ mod tests {
account_id: bob_account_id.clone(),
};
- let store =
- Store::new(Config::new(tmp_dir.path().join("kv4"))).expect("Unable to open kv store");
+ let store = Store::new(Config::new(tmp_dir.path().join("kv4"))).expect("Unable to open kv store");
let kv = open_kv_store(store.clone()).unwrap();
kv.clear().unwrap();
fund_account(&Arc::from(alice_provider.clone()), req, store, allowances)
@@ -622,17 +558,11 @@ mod tests {
let mut allowances: HashMap = HashMap::new();
allowances.insert(FundingRequestAccountType::User, user_allowance_dot);
allowances.insert(FundingRequestAccountType::Vault, vault_allowance_dot);
- allowances.insert(
- FundingRequestAccountType::StakedRelayer,
- staked_relayer_allowance_dot,
- );
+ allowances.insert(FundingRequestAccountType::StakedRelayer, staked_relayer_allowance_dot);
let expected_amount_planck: u128 = dot_to_planck(vault_allowance_dot);
let bob_provider = setup_provider(client.clone(), AccountKeyring::Bob).await;
- bob_provider
- .register_vault(100, dummy_public_key())
- .await
- .unwrap();
+ bob_provider.register_vault(100, dummy_public_key()).await.unwrap();
let alice_provider = setup_provider(client.clone(), AccountKeyring::Alice).await;
let bob_funds_before = alice_provider
@@ -643,8 +573,7 @@ mod tests {
account_id: bob_account_id.clone(),
};
- let store =
- Store::new(Config::new(tmp_dir.path().join("kv5"))).expect("Unable to open kv store");
+ let store = Store::new(Config::new(tmp_dir.path().join("kv5"))).expect("Unable to open kv store");
let kv = open_kv_store(store.clone()).unwrap();
kv.clear().unwrap();
fund_account(
diff --git a/faucet/src/main.rs b/faucet/src/main.rs
index 1b53e1c02..582a99ca4 100644
--- a/faucet/src/main.rs
+++ b/faucet/src/main.rs
@@ -1,28 +1,28 @@
mod error;
mod http;
+mod system;
use clap::Clap;
use error::Error;
-use runtime::substrate_subxt::PairSigner;
-use runtime::{PolkaBtcProvider, PolkaBtcRuntime};
-use std::sync::Arc;
+use runtime::{substrate_subxt::PairSigner, ConnectionManager, PolkaBtcRuntime};
+use system::{FaucetService, FaucetServiceConfig};
/// DOT faucet for enabling users to test PolkaBTC
#[derive(Clap)]
-#[clap(version = "0.1", author = "Interlay ")]
+#[clap(version = "0.2", author = "Interlay ")]
struct Opts {
- /// Parachain URL, can be over WebSockets or HTTP.
- #[clap(long, default_value = "ws://127.0.0.1:9944")]
- polka_btc_url: String,
+ /// Keyring / keyfile options.
+ #[clap(flatten)]
+ account_info: runtime::cli::ProviderUserOpts,
+
+ /// Connection settings for the BTC-Parachain.
+ #[clap(flatten)]
+ parachain: runtime::cli::ConnectionOpts,
/// Address to listen on for JSON-RPC requests.
#[clap(long, default_value = "[::0]:3033")]
http_addr: String,
- /// keyring / keyfile options.
- #[clap(flatten)]
- account_info: runtime::cli::ProviderUserOpts,
-
/// Comma separated list of allowed origins.
#[clap(long, default_value = "*")]
rpc_cors_domain: String,
@@ -42,23 +42,29 @@ struct Opts {
#[tokio::main]
async fn main() -> Result<(), Error> {
- env_logger::init();
+ env_logger::init_from_env(
+ env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, log::LevelFilter::Info.as_str()),
+ );
let opts: Opts = Opts::parse();
let (key_pair, _) = opts.account_info.get_key_pair()?;
let signer = PairSigner::::new(key_pair);
- let provider = Arc::new(PolkaBtcProvider::from_url(opts.polka_btc_url, signer).await?);
- let http_addr = opts.http_addr.parse()?;
- http::start(
- provider.clone(),
- http_addr,
- opts.rpc_cors_domain,
- opts.user_allowance,
- opts.vault_allowance,
- opts.staked_relayer_allowance,
+ ConnectionManager::<_, _, FaucetService>::new(
+ opts.parachain.polka_btc_url.clone(),
+ signer.clone(),
+ FaucetServiceConfig {
+ http_addr: opts.http_addr.parse()?,
+ rpc_cors_domain: opts.rpc_cors_domain,
+ user_allowance: opts.user_allowance,
+ vault_allowance: opts.vault_allowance,
+ staked_relayer_allowance: opts.staked_relayer_allowance,
+ },
+ opts.parachain.into(),
+ tokio::runtime::Handle::current(),
)
- .await;
+ .start()
+ .await?;
Ok(())
}
diff --git a/faucet/src/system.rs b/faucet/src/system.rs
new file mode 100644
index 000000000..f1a954655
--- /dev/null
+++ b/faucet/src/system.rs
@@ -0,0 +1,71 @@
+use crate::{http, Error};
+use async_trait::async_trait;
+use runtime::{on_shutdown, Error as RuntimeError, PolkaBtcProvider, Service, ShutdownReceiver};
+use std::net::SocketAddr;
+
+#[derive(Clone)]
+pub struct FaucetServiceConfig {
+ pub http_addr: SocketAddr,
+ pub rpc_cors_domain: String,
+ pub user_allowance: u128,
+ pub vault_allowance: u128,
+ pub staked_relayer_allowance: u128,
+}
+
+pub struct FaucetService {
+ btc_parachain: PolkaBtcProvider,
+ config: FaucetServiceConfig,
+ handle: tokio::runtime::Handle,
+ shutdown: ShutdownReceiver,
+}
+
+#[async_trait]
+impl Service for FaucetService {
+ async fn start(
+ btc_parachain: PolkaBtcProvider,
+ config: FaucetServiceConfig,
+ handle: tokio::runtime::Handle,
+ shutdown: ShutdownReceiver,
+ ) -> Result<(), RuntimeError> {
+ FaucetService::new(btc_parachain, config, handle, shutdown)
+ .run_service()
+ .await
+ .map_err(|_| RuntimeError::ChannelClosed)
+ }
+}
+
+impl FaucetService {
+ fn new(
+ btc_parachain: PolkaBtcProvider,
+ config: FaucetServiceConfig,
+ handle: tokio::runtime::Handle,
+ shutdown: ShutdownReceiver,
+ ) -> Self {
+ Self {
+ btc_parachain,
+ config,
+ handle,
+ shutdown,
+ }
+ }
+
+ async fn run_service(&self) -> Result<(), Error> {
+ let close_handle = http::start_http(
+ self.btc_parachain.clone(),
+ self.config.http_addr,
+ self.config.rpc_cors_domain.clone(),
+ self.config.user_allowance,
+ self.config.vault_allowance,
+ self.config.staked_relayer_allowance,
+ self.handle.clone(),
+ )
+ .await;
+
+ on_shutdown(self.shutdown.clone(), async move {
+ close_handle.close();
+ })
+ .await;
+
+ Ok(())
+ }
+}
diff --git a/oracle/Cargo.toml b/oracle/Cargo.toml
index 4939d5cba..6491486b9 100644
--- a/oracle/Cargo.toml
+++ b/oracle/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "oracle"
-version = "0.2.2"
+version = "0.5.0"
authors = ["Interlay "]
edition = "2018"
@@ -9,10 +9,9 @@ log = "0.4.0"
env_logger = "0.7.1"
clap = "3.0.0-beta.2"
tokio = { version = "0.2.22", features = ["full"] }
-runtime = { path = "../runtime" }
chrono = "0.4"
thiserror = "1.0"
reqwest = { version = "0.10.9", features = ["json"] }
-# Substrate dependencies
-sp-keyring = { git = "https://github.com/paritytech/substrate", branch = "rococo-v1" }
\ No newline at end of file
+# Workspace dependencies
+runtime = { path = "../runtime" }
diff --git a/oracle/src/main.rs b/oracle/src/main.rs
index a681f318f..8ff4c651a 100644
--- a/oracle/src/main.rs
+++ b/oracle/src/main.rs
@@ -3,24 +3,21 @@ mod error;
use clap::Clap;
use error::Error;
use log::{error, info};
-use runtime::substrate_subxt::PairSigner;
use runtime::{
- ExchangeRateOraclePallet, FixedPointNumber, FixedU128, PolkaBtcProvider, PolkaBtcRuntime,
+ substrate_subxt::PairSigner, ExchangeRateOraclePallet, FixedPointNumber, FixedU128, PolkaBtcProvider,
+ PolkaBtcRuntime,
};
-use std::collections::HashMap;
-use std::sync::Arc;
-use std::time::Duration;
+use std::{collections::HashMap, time::Duration};
use tokio::time::delay_for;
const ERR_RETRY_WAIT: Duration = Duration::from_secs(10);
async fn get_exchange_rate_from_coingecko() -> Result {
// https://www.coingecko.com/api/documentations/v3
- let resp =
- reqwest::get("https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=dot")
- .await?
- .json::>>()
- .await?;
+ let resp = reqwest::get("https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=dot")
+ .await?
+ .json::>>()
+ .await?;
Ok(*resp
.get("bitcoin")
@@ -44,8 +41,8 @@ struct Opts {
#[clap(long, default_value = "385523187")]
exchange_rate: u128,
- /// Timeout for exchange rate setter, default 30 minutes.
- #[clap(long, default_value = "1800000")]
+ /// Timeout for exchange rate setter, default 25 minutes.
+ #[clap(long, default_value = "1500000")]
timeout_ms: u64,
/// keyring / keyfile options.
@@ -55,20 +52,25 @@ struct Opts {
/// Fetch the exchange rate from CoinGecko.
#[clap(long, conflicts_with("exchange-rate"))]
coingecko: bool,
+
+ /// Timeout in milliseconds to wait for connection to btc-parachain.
+ #[clap(long, default_value = "60000")]
+ connection_timeout_ms: u64,
}
#[tokio::main]
async fn main() -> Result<(), Error> {
- env_logger::init();
+ env_logger::init_from_env(
+ env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, log::LevelFilter::Info.as_str()),
+ );
let opts: Opts = Opts::parse();
let (key_pair, _) = opts.account_info.get_key_pair()?;
let signer = PairSigner::::new(key_pair);
- let provider = Arc::new(PolkaBtcProvider::from_url(opts.polka_btc_url, signer).await?);
let timeout = Duration::from_millis(opts.timeout_ms);
- let exchange_rate = FixedU128::checked_from_rational(opts.exchange_rate, 100_000)
- .ok_or(Error::InvalidExchangeRate)?;
+ let exchange_rate =
+ FixedU128::checked_from_rational(opts.exchange_rate, 100_000).ok_or(Error::InvalidExchangeRate)?;
loop {
let exchange_rate = if opts.coingecko {
@@ -93,10 +95,19 @@ async fn main() -> Result<(), Error> {
chrono::offset::Local::now()
);
- match provider.set_exchange_rate_info(exchange_rate).await {
- Err(e) => error!("Error: {}", e.to_string()),
- _ => (),
- };
+ let result = PolkaBtcProvider::from_url_with_retry(
+ &opts.polka_btc_url.clone(),
+ signer.clone(),
+ Duration::from_millis(opts.connection_timeout_ms),
+ )
+ .await?
+ .set_exchange_rate_info(exchange_rate)
+ .await;
+
+ if let Err(e) = result {
+ error!("Error: {}", e.to_string());
+ }
+
delay_for(timeout).await;
}
}
diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml
index af7574a34..7c836436f 100644
--- a/runtime/Cargo.toml
+++ b/runtime/Cargo.toml
@@ -1,12 +1,20 @@
[package]
name = "runtime"
-version = "0.3.0"
+version = "0.5.0"
authors = ["Interlay "]
edition = "2018"
[features]
default = []
-testing-utils = ["substrate-subxt-client", "tempdir", "btc-parachain", "btc-parachain-service", "bitcoin", "rand"]
+testing-utils = [
+ "substrate-subxt/client",
+ "substrate-subxt-client",
+ "tempdir",
+ "btc-parachain",
+ "btc-parachain-service",
+ "bitcoin",
+ "rand",
+]
[dependencies]
parity-scale-codec = "2.0.0"
@@ -15,10 +23,10 @@ thiserror = "1.0"
serde_json = "1.0.57"
serde = "1.0.116"
tokio = { version = "0.2.22", features = ["full"] }
-jsonrpsee = "0.1.0"
futures = "0.3.5"
clap = "3.0.0-beta.2"
log = "0.4.0"
+url = "2"
# Substrate dependencies
sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "rococo-v1" }
@@ -30,85 +38,92 @@ frame-support = { git = "https://github.com/paritytech/substrate", branch = "roc
frame-system = { git = "https://github.com/paritytech/substrate", branch = "rococo-v1" }
# Subxt dependencies
-substrate-subxt-proc-macro = { git = "https://github.com/interlay/substrate-subxt", rev = "9ef6ed9" }
-substrate-subxt = { git = "https://github.com/interlay/substrate-subxt", rev = "9ef6ed9" }
+substrate-subxt-proc-macro = { git = "https://github.com/interlay/substrate-subxt", rev = "0283aa0" }
+substrate-subxt = { git = "https://github.com/interlay/substrate-subxt", rev = "0283aa0" }
+
+jsonrpsee-types = { git = "https://github.com/interlay/jsonrpsee", rev = "1c2ba33" }
+jsonrpsee-ws-client = { git = "https://github.com/interlay/jsonrpsee", rev = "1c2ba33" }
+
+# Polkadot dependencies
+xcm = { git = "https://github.com/paritytech/polkadot", branch = "rococo-v1" }
+parachain = { package = "polkadot-parachain", git = "https://github.com/paritytech/polkadot", branch = "rococo-v1" }
# Dependencies for the testing utils for integration tests
-substrate-subxt-client = { git = "https://github.com/interlay/substrate-subxt", rev = "9ef6ed9", optional = true }
+substrate-subxt-client = { git = "https://github.com/interlay/substrate-subxt", rev = "0283aa0", optional = true }
tempdir = {version = "0.3.7", optional = true }
-btc-parachain = { git = "https://gitlab.com/interlay/btc-parachain", branch = "dev", version = "0.5.0", features = ["aura-grandpa"], optional = true }
-btc-parachain-service = { git = "https://gitlab.com/interlay/btc-parachain", branch = "dev", version = "0.5.1", features = ["aura-grandpa"], optional = true }
+btc-parachain = { git = "https://github.com/interlay/btc-parachain", branch = "master", version = "0.5.0", features = ["aura-grandpa"], optional = true }
+btc-parachain-service = { git = "https://github.com/interlay/btc-parachain", branch = "master", version = "0.5.1", features = ["aura-grandpa"], optional = true }
bitcoin = { path = "../bitcoin", optional = true }
rand = { version = "0.7", optional = true }
[dependencies.module-bitcoin]
-git = "https://gitlab.com/interlay/btc-parachain"
-branch = "dev"
+git = "https://github.com/interlay/btc-parachain"
+branch = "master"
version = "0.5.0"
package = "bitcoin"
[dependencies.module-refund]
-git = "https://gitlab.com/interlay/btc-parachain"
-branch = "dev"
+git = "https://github.com/interlay/btc-parachain"
+branch = "master"
version = "0.5.0"
package = "refund"
[dependencies.module-btc-relay]
-git = "https://gitlab.com/interlay/btc-parachain"
-branch = "dev"
+git = "https://github.com/interlay/btc-parachain"
+branch = "master"
version = "0.5.0"
package = "btc-relay"
[dependencies.module-security]
-git = "https://gitlab.com/interlay/btc-parachain"
-branch = "dev"
+git = "https://github.com/interlay/btc-parachain"
+branch = "master"
version = "0.5.0"
package = "security"
[dependencies.module-staked-relayers]
-git = "https://gitlab.com/interlay/btc-parachain"
-branch = "dev"
+git = "https://github.com/interlay/btc-parachain"
+branch = "master"
version = "0.5.0"
package = "staked-relayers"
[dependencies.module-vault-registry]
-git = "https://gitlab.com/interlay/btc-parachain"
-branch = "dev"
+git = "https://github.com/interlay/btc-parachain"
+branch = "master"
version = "0.5.0"
package = "vault-registry"
[dependencies.module-exchange-rate-oracle-rpc-runtime-api]
-git = "https://gitlab.com/interlay/btc-parachain"
-branch = "dev"
+git = "https://github.com/interlay/btc-parachain"
+branch = "master"
version = "0.5.0"
package = "module-exchange-rate-oracle-rpc-runtime-api"
[dependencies.module-issue]
-git = "https://gitlab.com/interlay/btc-parachain"
-branch = "dev"
+git = "https://github.com/interlay/btc-parachain"
+branch = "master"
version = "0.5.0"
package = "issue"
[dependencies.module-redeem]
-git = "https://gitlab.com/interlay/btc-parachain"
-branch = "dev"
+git = "https://github.com/interlay/btc-parachain"
+branch = "master"
version = "0.5.0"
package = "redeem"
[dependencies.module-replace]
-git = "https://gitlab.com/interlay/btc-parachain"
-branch = "dev"
+git = "https://github.com/interlay/btc-parachain"
+branch = "master"
version = "0.5.0"
package = "replace"
[dependencies.module-exchange-rate-oracle]
-git = "https://gitlab.com/interlay/btc-parachain"
-branch = "dev"
+git = "https://github.com/interlay/btc-parachain"
+branch = "master"
version = "0.5.0"
package = "exchange-rate-oracle"
[dev-dependencies]
-substrate-subxt-client = { git = "https://github.com/interlay/substrate-subxt", rev = "9ef6ed9" }
+substrate-subxt-client = { git = "https://github.com/interlay/substrate-subxt", rev = "0283aa0" }
+btc-parachain = { git = "https://github.com/interlay/btc-parachain", branch = "master", version = "0.5.0", features = ["aura-grandpa"] }
+btc-parachain-service = { git = "https://github.com/interlay/btc-parachain", branch = "master", version = "0.5.0", features = ["aura-grandpa"] }
tempdir = "0.3.7"
-btc-parachain = { git = "https://gitlab.com/interlay/btc-parachain", branch = "dev", version = "0.5.0", features = ["aura-grandpa"] }
-btc-parachain-service = { git = "https://gitlab.com/interlay/btc-parachain", branch = "dev", version = "0.5.0", features = ["aura-grandpa"] }
diff --git a/runtime/src/cli.rs b/runtime/src/cli.rs
index b0b150032..e627a4f1d 100644
--- a/runtime/src/cli.rs
+++ b/runtime/src/cli.rs
@@ -1,10 +1,12 @@
-use crate::error::{Error, KeyLoadingError};
-use clap::Clap;
+use crate::{
+ error::{Error, KeyLoadingError},
+ ConnectionManagerConfig, RestartPolicy,
+};
-use sp_core::sr25519::Pair;
-use sp_core::Pair as _;
+use clap::Clap;
+use sp_core::{sr25519::Pair, Pair as _};
use sp_keyring::AccountKeyring;
-use std::collections::HashMap;
+use std::{collections::HashMap, time::Duration};
#[derive(Clap, Debug, Clone)]
pub struct ProviderUserOpts {
@@ -27,12 +29,10 @@ impl ProviderUserOpts {
/// Get the key pair and the username, the latter of which is used for wallet selection.
pub fn get_key_pair(&self) -> Result<(Pair, String), Error> {
// load parachain credentials
- let (pair, user_name) = match (self.keyfile.as_ref(), self.keyname.as_ref(), &self.keyring)
- {
- (Some(file_path), Some(keyname), None) => (
- get_credentials_from_file(&file_path, &keyname)?,
- keyname.to_string(),
- ),
+ let (pair, user_name) = match (self.keyfile.as_ref(), self.keyname.as_ref(), &self.keyring) {
+ (Some(file_path), Some(keyname), None) => {
+ (get_credentials_from_file(&file_path, &keyname)?, keyname.to_string())
+ }
(None, None, Some(keyring)) => (keyring.pair(), format!("{}", keyring)),
_ => panic!("Invalid arguments"), // should never occur, due to clap constraints
};
@@ -51,7 +51,40 @@ fn get_credentials_from_file(file_path: &str, keyname: &str) -> Result = serde_json::from_reader(reader)?;
let pair_str = map.get(keyname).ok_or(KeyLoadingError::KeyNotFound)?;
- let pair =
- Pair::from_string(pair_str, None).map_err(|e| KeyLoadingError::SecretStringError(e))?;
+ let pair = Pair::from_string(pair_str, None).map_err(|e| KeyLoadingError::SecretStringError(e))?;
Ok(pair)
}
+
+#[derive(Clap, Debug, Clone)]
+pub struct ConnectionOpts {
+ /// Parachain websocket URL.
+ #[clap(long, default_value = "ws://127.0.0.1:9944")]
+ pub polka_btc_url: String,
+
+ /// Timeout in milliseconds to wait for connection to btc-parachain.
+ #[clap(long, default_value = "60000")]
+ pub polka_btc_connection_timeout_ms: u64,
+
+ /// What to do if the connection to the btc-parachain drops.
+ #[clap(long, default_value = "always")]
+ pub restart_policy: RestartPolicy,
+
+ /// Maximum number of concurrent requests
+ #[clap(long)]
+ pub max_concurrent_requests: Option,
+
+ /// Maximum notification capacity for each subscription
+ #[clap(long)]
+ pub max_notifs_per_subscription: Option,
+}
+
+impl Into for ConnectionOpts {
+ fn into(self) -> ConnectionManagerConfig {
+ ConnectionManagerConfig {
+ connection_timeout: Duration::from_millis(self.polka_btc_connection_timeout_ms),
+ restart_policy: self.restart_policy,
+ max_concurrent_requests: self.max_concurrent_requests,
+ max_notifs_per_subscription: self.max_notifs_per_subscription,
+ }
+ }
+}
diff --git a/runtime/src/conn.rs b/runtime/src/conn.rs
new file mode 100644
index 000000000..2e6bbedbb
--- /dev/null
+++ b/runtime/src/conn.rs
@@ -0,0 +1,201 @@
+use crate::{error::JsonRpseeError, Error, PolkaBtcSigner};
+use async_trait::async_trait;
+use futures::{Future, FutureExt};
+use jsonrpsee_ws_client::{WsClient, WsConfig};
+use log::{info, trace};
+use std::{marker::PhantomData, str::FromStr, sync::Arc, time::Duration};
+use substrate_subxt::RpcClient;
+use tokio::{
+ runtime::Handle,
+ time::{delay_for, timeout},
+};
+
+const RETRY_TIMEOUT: Duration = Duration::from_millis(1000);
+const CONNECTION_TIMEOUT: Duration = Duration::from_secs(10);
+
+pub type ShutdownReceiver = tokio::sync::watch::Receiver>;
+
+#[async_trait]
+pub trait Provider {
+ async fn connect(rpc_client: T, signer: PolkaBtcSigner) -> Result
+ where
+ Self: Sized,
+ T: Into + Send;
+}
+
+#[async_trait]
+pub trait Service {
+ async fn start(provider: P, config: C, handle: Handle, shutdown: ShutdownReceiver) -> Result<(), Error>;
+}
+
+pub(crate) async fn new_websocket_client(
+ url: &String,
+ max_concurrent_requests: Option,
+ max_notifs_per_subscription: Option,
+) -> Result {
+ let parsed_url = url::Url::parse(&url)?;
+ let path = parsed_url.path();
+ let config = WsConfig {
+ url,
+ max_request_body_size: 10 * 1024 * 1024,
+ request_timeout: None,
+ connection_timeout: CONNECTION_TIMEOUT,
+ origin: None,
+ handshake_url: path.into(),
+ max_concurrent_requests: max_concurrent_requests.unwrap_or(256),
+ max_notifs_per_subscription: max_notifs_per_subscription.unwrap_or(128),
+ };
+ Ok(WsClient::new(config).await?)
+}
+
+pub(crate) async fn new_websocket_client_with_retry(
+ url: &String,
+ max_concurrent_requests: Option,
+ max_notifs_per_subscription: Option,
+ connection_timeout: Duration,
+) -> Result {
+ info!("Connecting to the btc-parachain...");
+ timeout(connection_timeout, async move {
+ loop {
+ match new_websocket_client(url, max_concurrent_requests, max_notifs_per_subscription).await {
+ Err(Error::JsonRpseeError(JsonRpseeError::TransportError(err))) => {
+ trace!("could not connect to parachain: {}", err);
+ delay_for(RETRY_TIMEOUT).await;
+ continue;
+ }
+ Ok(rpc) => {
+ info!("Connected!");
+ return Ok(rpc);
+ }
+ Err(err) => return Err(err),
+ }
+ }
+ })
+ .await?
+}
+
+#[derive(Clone, Debug)]
+pub enum RestartPolicy {
+ Never,
+ Always,
+}
+
+impl FromStr for RestartPolicy {
+ type Err = String;
+ fn from_str(code: &str) -> Result {
+ match code {
+ "never" => Ok(RestartPolicy::Never),
+ "always" => Ok(RestartPolicy::Always),
+ _ => Err("Could not parse input as RestartPolicy".to_string()),
+ }
+ }
+}
+
+/// Connection settings for the service
+pub struct ManagerConfig {
+ /// Fail to connect to server if elapsed
+ pub connection_timeout: Duration,
+ /// Whether to restart the client
+ pub restart_policy: RestartPolicy,
+ /// Maximum number of concurrent requests
+ pub max_concurrent_requests: Option,
+ /// Maximum notification capacity for each subscription
+ pub max_notifs_per_subscription: Option,
+}
+
+pub struct Manager> {
+ url: String,
+ signer: PolkaBtcSigner,
+ service_config: C,
+ manager_config: ManagerConfig,
+ handle: Handle,
+ _marker: PhantomData<(P, S)>,
+}
+
+impl> Manager {
+ pub fn new(
+ url: String,
+ signer: PolkaBtcSigner,
+ service_config: C,
+ manager_config: ManagerConfig,
+ handle: Handle,
+ ) -> Self {
+ Self {
+ url,
+ signer,
+ service_config,
+ manager_config,
+ handle,
+ _marker: PhantomData::default(),
+ }
+ }
+
+ pub async fn start(&self) -> Result<(), Error> {
+ loop {
+ let ws_client = new_websocket_client_with_retry(
+ &self.url,
+ self.manager_config.max_concurrent_requests,
+ self.manager_config.max_notifs_per_subscription,
+ self.manager_config.connection_timeout,
+ )
+ .await?;
+ let ws_client = Arc::new(ws_client);
+
+ let signer = self.signer.clone();
+ let config = self.service_config.clone();
+ let handle = self.handle.clone();
+
+ let (shutdown_sender, shutdown_receiver) = tokio::sync::watch::channel(None);
+ let wait_for_shutdown = is_connected(ws_client.clone());
+
+ // run service and shutdown listener to terminate child
+ // processes if the websocket client disconnects
+ let _ = tokio::join! {
+ async move {
+ // TODO: propogate shutdown signal from children
+ wait_for_shutdown.await;
+ // signal shutdown to child processes
+ let _ = shutdown_sender.broadcast(Some(()));
+ },
+ async move {
+ let provider = P::connect(ws_client, signer).await?;
+ let _ = S::start(provider, config, handle, shutdown_receiver).await;
+ Ok::<(), Error>(())
+ }
+ };
+
+ info!("Disconnected");
+
+ match self.manager_config.restart_policy {
+ RestartPolicy::Never => return Err(Error::ChannelClosed),
+ RestartPolicy::Always => continue,
+ };
+ }
+ }
+}
+
+async fn is_connected(client: Arc) {
+ while client.is_connected() {
+ delay_for(Duration::from_millis(500)).await;
+ }
+}
+
+pub async fn wait_or_shutdown(mut shutdown: ShutdownReceiver, future2: impl Future) {
+ let future1 = async move { while let Some(None) = shutdown.recv().await {} }.fuse();
+ let future2 = future2.fuse();
+
+ futures::pin_mut!(future1);
+ futures::pin_mut!(future2);
+
+ let _ = futures::select! {
+ _ = future1 => (),
+ _ = future2 => (),
+ };
+}
+
+pub async fn on_shutdown(mut shutdown: ShutdownReceiver, future2: impl Future) {
+ let future1 = async move { while let Some(None) = shutdown.recv().await {} }.fuse();
+
+ future1.await;
+ future2.await;
+}
diff --git a/runtime/src/error.rs b/runtime/src/error.rs
index fe23e2740..60b2751c6 100644
--- a/runtime/src/error.rs
+++ b/runtime/src/error.rs
@@ -1,12 +1,14 @@
-use jsonrpsee::{client::RequestError as JsonRPSeeError, transport::ws::WsNewDnsError};
+pub use jsonrpsee_types::error::Error as JsonRpseeError;
+pub use substrate_subxt::Error as XtError;
+
+use jsonrpsee_ws_client::transport::WsConnectError;
use parity_scale_codec::Error as CodecError;
use serde_json::Error as SerdeJsonError;
use sp_core::crypto::SecretStringError;
-use std::array::TryFromSliceError;
-use std::io::Error as IoError;
-use std::num::TryFromIntError;
-pub use substrate_subxt::Error as XtError;
+use std::{array::TryFromSliceError, io::Error as IoError, num::TryFromIntError};
use thiserror::Error;
+use tokio::time::Elapsed;
+use url::ParseError as UrlParseError;
#[derive(Error, Debug)]
pub enum Error {
@@ -22,13 +24,17 @@ pub enum Error {
BlockNotFound,
#[error("Could not get vault")]
VaultNotFound,
+ #[error("Vault has been liquidated")]
+ VaultLiquidated,
+ #[error("Vault has stolen BTC")]
+ VaultCommittedTheft,
+ #[error("Channel closed unexpectedly")]
+ ChannelClosed,
+
#[error("Callback error: {0}")]
CallbackError(Box),
-
#[error("Failed to load credentials from file: {0}")]
KeyLoadingFailure(#[from] KeyLoadingError),
- #[error("Channel unexpectedly closed")]
- ChannelClosed,
#[error("Error serializing: {0}")]
Serialize(#[from] TryFromSliceError),
#[error("Error converting: {0}")]
@@ -40,10 +46,14 @@ pub enum Error {
#[error("Error encoding json data: {0}")]
SerdeJsonError(#[from] SerdeJsonError),
#[error("Error getting json-rpsee data: {0}")]
- JsonRPSeeError(#[from] JsonRPSeeError),
+ JsonRpseeError(#[from] JsonRpseeError),
/// Occurs during websocket handshake
#[error("Rpc error: {0}")]
- WsHandshake(#[from] WsNewDnsError),
+ WsConnectError(#[from] WsConnectError),
+ #[error("Timeout: {0}")]
+ TimeElapsed(#[from] Elapsed),
+ #[error("UrlParseError: {0}")]
+ UrlParseError(#[from] UrlParseError),
}
#[derive(Error, Debug)]
diff --git a/runtime/src/integration/bitcoin_simulator.rs b/runtime/src/integration/bitcoin_simulator.rs
index c9194ab2a..a1c5b1cac 100644
--- a/runtime/src/integration/bitcoin_simulator.rs
+++ b/runtime/src/integration/bitcoin_simulator.rs
@@ -6,37 +6,38 @@ use crate::{BtcAddress, BtcRelayPallet, PolkaBtcProvider};
use async_trait::async_trait;
use bitcoin::{
secp256k1::{rand::rngs::OsRng, PublicKey, Secp256k1, SecretKey},
- serialize, BitcoinCoreApi, Block, BlockHash, BlockHeader, Error as BitcoinError,
- GetBlockResult, Hash, LockedTransaction, Network, OutPoint, PartialAddress, PartialMerkleTree,
- Script, Transaction, TransactionMetadata, TxIn, TxOut, Txid, Uint256, PUBLIC_KEY_SIZE,
+ serialize, BitcoinCoreApi, Block, BlockHash, BlockHeader, Error as BitcoinError, GetBlockResult, Hash,
+ LockedTransaction, Network, OutPoint, PartialAddress, PartialMerkleTree, Script, Transaction, TransactionMetadata,
+ TxIn, TxOut, Txid, Uint256, PUBLIC_KEY_SIZE,
};
use rand::{thread_rng, Rng};
use sp_core::{H160, H256, U256};
-use std::convert::TryInto;
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::sync::{Mutex, RwLock};
-use tokio::time::delay_for;
+use std::{convert::TryInto, sync::Arc, time::Duration};
+use tokio::{
+ sync::{Mutex, RwLock},
+ time::delay_for,
+};
/// A simulated bitcoin-core interface. It combines the roles of bitcoin-core and the
/// staked relayer: it automatically relays the generated transactions to the parachain.
/// It does the minimum amount of work it can get away with, and the relayed data may
/// be technically invalid. For example, all generated transactions share the same dummy
/// input uxto.
+#[derive(Clone)]
pub struct MockBitcoinCore {
- provider: Arc,
- blocks: RwLock>,
- mempool: RwLock>,
+ provider: PolkaBtcProvider,
+ blocks: Arc>>,
+ mempool: Arc>>,
transaction_creation_lock: Arc>,
}
impl MockBitcoinCore {
/// Creates a new instance, and initializes parachain's btc-relay
- pub async fn new(provider: Arc) -> Self {
+ pub async fn new(provider: PolkaBtcProvider) -> Self {
let ret = Self {
provider,
- blocks: RwLock::new(vec![]),
- mempool: RwLock::new(vec![]),
+ blocks: Arc::new(RwLock::new(vec![])),
+ mempool: Arc::new(RwLock::new(vec![])),
transaction_creation_lock: Arc::new(Mutex::new(())),
};
@@ -54,11 +55,11 @@ impl MockBitcoinCore {
}
/// Creates a new instance, but does not initializes parachain's btc-relay
- pub async fn new_uninitialized(provider: Arc) -> Self {
+ pub async fn new_uninitialized(provider: PolkaBtcProvider) -> Self {
Self {
provider,
- blocks: RwLock::new(vec![]),
- mempool: RwLock::new(vec![]),
+ blocks: Arc::new(RwLock::new(vec![])),
+ mempool: Arc::new(RwLock::new(vec![])),
transaction_creation_lock: Arc::new(Mutex::new(())),
}
}
@@ -117,12 +118,8 @@ impl MockBitcoinCore {
block
}
- fn generate_normal_transaction(
- address: &A,
- reward: u64,
- ) -> Transaction {
- let address: BtcAddress =
- BtcAddress::decode_str(&address.encode_str(Network::Regtest).unwrap()).unwrap();
+ fn generate_normal_transaction(address: &A, reward: u64) -> Transaction {
+ let address: BtcAddress = BtcAddress::decode_str(&address.encode_str(Network::Regtest).unwrap()).unwrap();
let address = Script::from(address.to_script().as_bytes().to_vec());
Transaction {
@@ -138,15 +135,13 @@ impl MockBitcoinCore {
// actual contents of don't script_sig don't really matter as long as it contains
// a parsable script
script_sig: Script::from(vec![
- 0, 71, 48, 68, 2, 32, 91, 128, 41, 150, 96, 53, 187, 63, 230, 129, 53, 234,
- 210, 186, 21, 187, 98, 38, 255, 112, 30, 27, 228, 29, 132, 140, 155, 62, 123,
- 216, 232, 168, 2, 32, 72, 126, 179, 207, 142, 8, 99, 8, 32, 78, 244, 166, 106,
- 160, 207, 227, 61, 210, 172, 234, 234, 93, 59, 159, 79, 12, 194, 240, 212, 3,
- 120, 50, 1, 71, 81, 33, 3, 113, 209, 131, 177, 9, 29, 242, 229, 15, 217, 247,
- 165, 78, 111, 80, 79, 50, 200, 117, 80, 30, 233, 210, 167, 133, 175, 62, 253,
- 134, 127, 212, 51, 33, 2, 128, 200, 184, 235, 148, 25, 43, 34, 28, 173, 55, 54,
- 189, 164, 187, 243, 243, 152, 7, 84, 210, 85, 156, 238, 77, 97, 188, 240, 162,
- 197, 105, 62, 82, 174,
+ 0, 71, 48, 68, 2, 32, 91, 128, 41, 150, 96, 53, 187, 63, 230, 129, 53, 234, 210, 186, 21, 187, 98,
+ 38, 255, 112, 30, 27, 228, 29, 132, 140, 155, 62, 123, 216, 232, 168, 2, 32, 72, 126, 179, 207,
+ 142, 8, 99, 8, 32, 78, 244, 166, 106, 160, 207, 227, 61, 210, 172, 234, 234, 93, 59, 159, 79, 12,
+ 194, 240, 212, 3, 120, 50, 1, 71, 81, 33, 3, 113, 209, 131, 177, 9, 29, 242, 229, 15, 217, 247,
+ 165, 78, 111, 80, 79, 50, 200, 117, 80, 30, 233, 210, 167, 133, 175, 62, 253, 134, 127, 212, 51,
+ 33, 2, 128, 200, 184, 235, 148, 25, 43, 34, 28, 173, 55, 54, 189, 164, 187, 243, 243, 152, 7, 84,
+ 210, 85, 156, 238, 77, 97, 188, 240, 162, 197, 105, 62, 82, 174,
]),
// not checked
sequence: 0,
@@ -160,11 +155,7 @@ impl MockBitcoinCore {
}
}
- fn generate_coinbase_transaction(
- address: &BtcAddress,
- reward: u64,
- height: u32,
- ) -> Transaction {
+ fn generate_coinbase_transaction(address: &BtcAddress, reward: u64, height: u32) -> Transaction {
let address = Script::from(address.to_script().as_bytes().to_vec());
// note that we set lock_time to height, otherwise we might generate blocks with
@@ -219,11 +210,7 @@ impl BitcoinCoreApi for MockBitcoinCore {
async fn get_block_count(&self) -> Result {
Ok((self.blocks.read().await.len() - 1).try_into().unwrap())
}
- async fn get_raw_tx_for(
- &self,
- txid: &Txid,
- _block_hash: &BlockHash,
- ) -> Result, BitcoinError> {
+ async fn get_raw_tx_for(&self, txid: &Txid, _block_hash: &BlockHash) -> Result, BitcoinError> {
let blocks = self.blocks.read().await;
let transaction = blocks
@@ -233,11 +220,7 @@ impl BitcoinCoreApi for MockBitcoinCore {
Ok(serialize(transaction))
}
- async fn get_proof_for(
- &self,
- txid: Txid,
- _block_hash: &BlockHash,
- ) -> Result, BitcoinError> {
+ async fn get_proof_for(&self, txid: Txid, _block_hash: &BlockHash) -> Result, BitcoinError> {
let mut proof = Vec::new();
let blocks = self.blocks.read().await;
@@ -256,20 +239,13 @@ impl BitcoinCoreApi for MockBitcoinCore {
Ok(proof)
}
- async fn get_block_hash_for(&self, height: u32) -> Result {
+ async fn get_block_hash(&self, height: u32) -> Result {
let blocks = self.blocks.read().await;
- let block = blocks
- .get(height as usize)
- .ok_or(BitcoinError::InvalidBitcoinHeight)?;
+ let block = blocks.get(height as usize).ok_or(BitcoinError::InvalidBitcoinHeight)?;
Ok(block.header.block_hash())
}
async fn is_block_known(&self, block_hash: BlockHash) -> Result {
- Ok(self
- .blocks
- .read()
- .await
- .iter()
- .any(|x| x.block_hash() == block_hash))
+ Ok(self.blocks.read().await.iter().any(|x| x.block_hash() == block_hash))
}
async fn get_new_address(&self) -> Result {
let bytes: [u8; 20] = (0..20)
@@ -281,9 +257,7 @@ impl BitcoinCoreApi for MockBitcoinCore {
let address = BtcAddress::P2PKH(H160::from(bytes));
Ok(A::decode_str(&address.encode_str(Network::Regtest)?)?)
}
- async fn get_new_public_key + 'static>(
- &self,
- ) -> Result {
+ async fn get_new_public_key + 'static>(&self) -> Result {
let secp = Secp256k1::new();
let mut rng = OsRng::new().unwrap();
let secret_key = SecretKey::new(&mut rng);
@@ -309,6 +283,14 @@ impl BitcoinCoreApi for MockBitcoinCore {
.ok_or(BitcoinError::InvalidBitcoinHeight)?;
Ok(block.clone())
}
+ async fn get_block_header(&self, hash: &BlockHash) -> Result {
+ let blocks = self.blocks.read().await;
+ let block = blocks
+ .iter()
+ .find(|x| &x.block_hash() == hash)
+ .ok_or(BitcoinError::InvalidBitcoinHeight)?;
+ Ok(block.header.clone())
+ }
async fn get_block_info(&self, hash: &BlockHash) -> Result {
let blocks = self.blocks.read().await;
@@ -340,9 +322,8 @@ impl BitcoinCoreApi for MockBitcoinCore {
})
}
async fn get_mempool_transactions<'a>(
- self: Arc,
- ) -> Result> + Send + 'a>, BitcoinError>
- {
+ self: &'a Self,
+ ) -> Result> + Send + 'a>, BitcoinError> {
let transactions = (*self.mempool.read().await).clone();
Ok(Box::new(transactions.into_iter().map(|x| Ok(x))))
}
@@ -356,11 +337,7 @@ impl BitcoinCoreApi for MockBitcoinCore {
// we have to be careful not to deadlock, so limit the scope of the lock
let blocks = (*self.blocks.read().await).clone();
- if let Some(x) = blocks
- .iter()
- .enumerate()
- .find(|x| x.1.txdata[1].txid() == txid)
- {
+ if let Some(x) = blocks.iter().enumerate().find(|x| x.1.txdata[1].txid() == txid) {
break (x.0, x.1.clone());
}
tokio::time::delay_for(Duration::from_secs(1)).await;
@@ -398,13 +375,11 @@ impl BitcoinCoreApi for MockBitcoinCore {
Ok(LockedTransaction::new(
transaction,
- self.transaction_creation_lock.clone().lock_owned().await,
+ Some(self.transaction_creation_lock.clone().lock_owned().await),
))
}
async fn send_transaction(&self, transaction: LockedTransaction) -> Result {
- let block = self
- .generate_block_with_transaction(&transaction.transaction)
- .await;
+ let block = self.generate_block_with_transaction(&transaction.transaction).await;
self.send_block(block.clone()).await;
Ok(transaction.transaction.txid())
}
@@ -441,13 +416,7 @@ impl BitcoinCoreApi for MockBitcoinCore {
}
async fn wallet_has_public_key(&self, _public_key: P) -> Result
where
- P: Into<[u8; PUBLIC_KEY_SIZE]>
- + From<[u8; PUBLIC_KEY_SIZE]>
- + Clone
- + PartialEq
- + Send
- + Sync
- + 'static,
+ P: Into<[u8; PUBLIC_KEY_SIZE]> + From<[u8; PUBLIC_KEY_SIZE]> + Clone + PartialEq + Send + Sync + 'static,
{
Ok(true)
}
diff --git a/runtime/src/integration/mod.rs b/runtime/src/integration/mod.rs
index 26ebf28ff..d657b1032 100644
--- a/runtime/src/integration/mod.rs
+++ b/runtime/src/integration/mod.rs
@@ -1,25 +1,19 @@
+#![cfg(feature = "testing-utils")]
+
mod bitcoin_simulator;
-use crate::rpc::FeePallet;
-use crate::rpc::IssuePallet;
-use crate::rpc::VaultRegistryPallet;
-use crate::AccountId;
-use crate::H256Le;
-use crate::PolkaBtcProvider;
-use crate::PolkaBtcRuntime;
-use bitcoin::BitcoinCoreApi;
-use bitcoin::BlockHash;
-use bitcoin::Txid;
+use crate::{
+ rpc::{FeePallet, IssuePallet, VaultRegistryPallet},
+ AccountId, H256Le, PolkaBtcProvider, PolkaBtcRuntime,
+};
+use bitcoin::{BitcoinCoreApi, BlockHash, Txid};
use futures::{future::Either, pin_mut, Future, FutureExt, SinkExt, StreamExt};
-use jsonrpsee::Client as JsonRpseeClient;
use sp_keyring::AccountKeyring;
use sp_runtime::FixedPointNumber;
-use std::sync::Arc;
use std::time::Duration;
-use substrate_subxt::Event;
-use substrate_subxt::PairSigner;
+use substrate_subxt::{Event, PairSigner};
use substrate_subxt_client::{
- DatabaseConfig, KeystoreConfig, Role, SubxtClient, SubxtClientConfig,
+ DatabaseConfig, KeystoreConfig, Role, SubxtClient, SubxtClientConfig, WasmExecutionMethod,
};
use tempdir::TempDir;
use tokio::time::timeout;
@@ -50,7 +44,7 @@ impl Translate for BlockHash {
/// Start a new instance of the parachain. The second item in the returned tuple must remain in
/// scope as long as the parachain is active, since dropping it will remove the temporary directory
/// that the parachain uses
-pub async fn default_provider_client(key: AccountKeyring) -> (JsonRpseeClient, TempDir) {
+pub async fn default_provider_client(key: AccountKeyring) -> (SubxtClient, TempDir) {
let tmp = TempDir::new("btc-parachain-").expect("failed to create tempdir");
let config = SubxtClientConfig {
impl_name: "btc-parachain-full-client",
@@ -67,6 +61,7 @@ pub async fn default_provider_client(key: AccountKeyring) -> (JsonRpseeClient, T
chain_spec: btc_parachain::chain_spec::development_config(),
role: Role::Authority(key.clone()),
telemetry: None,
+ wasm_method: WasmExecutionMethod::Compiled,
};
let client = SubxtClient::from_config(config, btc_parachain_service::new_full)
@@ -76,25 +71,16 @@ pub async fn default_provider_client(key: AccountKeyring) -> (JsonRpseeClient, T
}
/// Create a new provider with the given keyring
-pub async fn setup_provider(client: JsonRpseeClient, key: AccountKeyring) -> Arc {
+pub async fn setup_provider(client: SubxtClient, key: AccountKeyring) -> PolkaBtcProvider {
let signer = PairSigner::::new(key.pair());
- let ret = PolkaBtcProvider::new(client, signer)
+ PolkaBtcProvider::new(client, signer)
.await
- .expect("Error creating provider");
- Arc::new(ret)
+ .expect("Error creating provider")
}
/// request, pay and execute an issue
-pub async fn assert_issue(
- provider: &PolkaBtcProvider,
- btc_rpc: &MockBitcoinCore,
- vault_id: &AccountId,
- amount: u128,
-) {
- let issue = provider
- .request_issue(amount, vault_id.clone(), 10000)
- .await
- .unwrap();
+pub async fn assert_issue(provider: &PolkaBtcProvider, btc_rpc: &MockBitcoinCore, vault_id: &AccountId, amount: u128) {
+ let issue = provider.request_issue(amount, vault_id.clone(), 10000).await.unwrap();
let metadata = btc_rpc
.send_to_address(
@@ -119,10 +105,7 @@ pub async fn assert_issue(
}
/// calculate how much collateral the vault requires to accept an issue of the given size
-pub async fn get_required_vault_collateral_for_issue(
- provider: &PolkaBtcProvider,
- amount: u128,
-) -> u128 {
+pub async fn get_required_vault_collateral_for_issue(provider: &PolkaBtcProvider, amount: u128) -> u128 {
let fee = provider.get_issue_fee().await.unwrap();
let amount_btc_including_fee = amount + fee.checked_mul_int(amount).unwrap();
provider
@@ -132,7 +115,7 @@ pub async fn get_required_vault_collateral_for_issue(
}
/// wait for an event to occur. After the specified error, this will panic. This returns the event.
-pub async fn assert_event(duration: Duration, provider: Arc, f: F) -> T
+pub async fn assert_event(duration: Duration, provider: PolkaBtcProvider, f: F) -> T
where
T: Event + Clone + std::fmt::Debug,
F: Fn(T) -> bool,
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 25601137c..0e4fad18d 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -1,7 +1,10 @@
pub mod cli;
-mod error;
pub mod pallets;
+
+mod conn;
+mod error;
mod rpc;
+mod types;
#[cfg(test)]
mod tests;
@@ -10,39 +13,52 @@ mod tests;
pub mod integration;
pub use btc_relay::{
- BitcoinBlockHeight, BlockBuilder, BtcAddress, BtcPublicKey, Formattable, H256Le,
- RawBlockHeader, RichBlockHeader,
+ BitcoinBlockHeight, BlockBuilder, BtcAddress, BtcPublicKey, Formattable, H256Le, RawBlockHeader, RichBlockHeader,
+};
+pub use conn::{
+ on_shutdown, wait_or_shutdown, Manager as ConnectionManager, ManagerConfig as ConnectionManagerConfig, Provider,
+ RestartPolicy, Service, ShutdownReceiver,
};
pub use error::{Error, XtError};
-use pallets::*;
pub use rpc::{
- AccountId, BtcRelayPallet, BtcTxFeesPerByte, DotBalancesPallet, ExchangeRateOraclePallet,
- FeePallet, IssuePallet, PolkaBtcHeader, PolkaBtcIssueRequest, PolkaBtcProvider,
- PolkaBtcRedeemRequest, PolkaBtcRefundRequest, PolkaBtcReplaceRequest,
- PolkaBtcRequestIssueEvent, PolkaBtcStatusUpdate, PolkaBtcVault, RedeemPallet, RefundPallet,
- ReplacePallet, SecurityPallet, StakedRelayerPallet, TimestampPallet, UtilFuncs,
- VaultRegistryPallet,
+ BtcRelayPallet, BtcTxFeesPerByte, DotBalancesPallet, ExchangeRateOraclePallet, FeePallet, IssuePallet,
+ PolkaBtcProvider, RedeemPallet, RefundPallet, ReplacePallet, SecurityPallet, StakedRelayerPallet, TimestampPallet,
+ UtilFuncs, VaultRegistryPallet,
};
pub use security::{ErrorCode, StatusCode};
pub use sp_arithmetic::{traits as FixedPointTraits, FixedI128, FixedPointNumber, FixedU128};
-use sp_core::{H160, H256};
pub use sp_runtime;
+pub use substrate_subxt;
+pub use types::*;
+pub use vault_registry::VaultStatus;
+
+use pallets::*;
+use sp_core::{H160, H256};
use sp_runtime::{
generic::Header,
traits::{BlakeTwo256, IdentifyAccount, Verify},
MultiSignature, OpaqueExtrinsic,
};
use std::collections::BTreeSet;
-pub use substrate_subxt;
-use substrate_subxt::register_default_type_sizes;
-use substrate_subxt::system::SystemEventTypeRegistry;
-use substrate_subxt::EventTypeRegistry;
-use substrate_subxt::{balances, extrinsic::DefaultExtra, sudo, system, Runtime};
+use substrate_subxt::{
+ balances, extrinsic::DefaultExtra, register_default_type_sizes, sudo, system, system::SystemEventTypeRegistry,
+ EventTypeRegistry, Runtime,
+};
+
+// cumulus / polkadot types
+use parachain::primitives::{Id as ParaId, RelayChainBlockNumber};
+use xcm::v0::{Error as XcmError, NetworkId};
pub const MINIMUM_STAKE: u128 = 100;
pub const TX_FEES: u128 = 2000000000;
pub const PLANCK_PER_DOT: u128 = 10000000000;
+pub const MILLISECS_PER_BLOCK: u64 = 6000;
+
+// These time units are defined in number of blocks.
+pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);
+pub const HOURS: BlockNumber = MINUTES * 60;
+
pub type Balance = u128;
#[derive(Debug, Clone, Eq, PartialEq)]
@@ -59,13 +75,19 @@ impl Runtime for PolkaBtcRuntime {
}
}
+/// An index to a block.
+pub type BlockNumber = u32;
+
+/// Some way of identifying an account on the chain.
+pub type AccountId = <::Signer as IdentifyAccount>::AccountId;
+
// TODO: use types from actual runtime
impl system::System for PolkaBtcRuntime {
type Index = u32;
- type BlockNumber = u32;
- type Hash = sp_core::H256;
+ type BlockNumber = BlockNumber;
+ type Hash = H256;
type Hashing = BlakeTwo256;
- type AccountId = <::Signer as IdentifyAccount>::AccountId;
+ type AccountId = AccountId;
type Address = Self::AccountId;
type Header = Header;
type Extrinsic = OpaqueExtrinsic;
@@ -77,7 +99,7 @@ impl pallets::Core for PolkaBtcRuntime {
type DOT = Balance;
type PolkaBTC = Balance;
type BTCBalance = Balance;
- type RichBlockHeader = RichBlockHeader;
+ type RichBlockHeader = RichBlockHeader;
type H256Le = H256Le;
type H160 = H160;
type H256 = H256;
@@ -89,6 +111,13 @@ impl pallets::Core for PolkaBtcRuntime {
type StatusUpdateId = u64;
type SignedFixedPoint = FixedI128;
type UnsignedFixedPoint = FixedU128;
+ type VaultStatus = VaultStatus;
+
+ // cumulus / polkadot types
+ type XcmError = XcmError;
+ type NetworkId = NetworkId;
+ type RelayChainBlockNumber = RelayChainBlockNumber;
+ type ParaId = ParaId;
}
impl balances::Balances for PolkaBtcRuntime {
@@ -132,3 +161,9 @@ impl fee::Fee for PolkaBtcRuntime {}
impl sla::Sla for PolkaBtcRuntime {}
impl treasury::Treasury for PolkaBtcRuntime {}
+
+pub const BTC_RELAY_MODULE: &str = "BTCRelay";
+pub const ISSUE_MODULE: &str = "Issue";
+
+pub const DUPLICATE_BLOCK_ERROR: &str = "DuplicateBlock";
+pub const ISSUE_COMPLETED_ERROR: &str = "IssueCompleted";
diff --git a/runtime/src/pallets/balances_dot.rs b/runtime/src/pallets/balances_dot.rs
index a1c963d0f..55d271627 100644
--- a/runtime/src/pallets/balances_dot.rs
+++ b/runtime/src/pallets/balances_dot.rs
@@ -3,8 +3,7 @@ use frame_support::Parameter;
use parity_scale_codec::{Codec, Decode, Encode};
use sp_runtime::traits::{AtLeast32Bit, MaybeSerialize, Member};
use std::fmt::Debug;
-use substrate_subxt::balances::AccountData;
-use substrate_subxt::system::System;
+use substrate_subxt::{balances::AccountData, system::System};
use substrate_subxt_proc_macro::{module, Call, Event, Store};
#[module]
diff --git a/runtime/src/pallets/btc_relay.rs b/runtime/src/pallets/btc_relay.rs
index 7d42e8899..78746a28b 100644
--- a/runtime/src/pallets/btc_relay.rs
+++ b/runtime/src/pallets/btc_relay.rs
@@ -1,7 +1,7 @@
use super::Core;
use core::marker::PhantomData;
pub use module_bitcoin::{formatter::Formattable, types::*};
-pub use module_btc_relay::{BtcAddress, BtcPublicKey};
+pub use module_btc_relay::{BtcAddress, BtcPublicKey, RichBlockHeader};
use parity_scale_codec::{Decode, Encode};
use std::fmt::Debug;
use substrate_subxt_proc_macro::{module, Call, Event, Store};
@@ -61,6 +61,7 @@ pub struct InitializedEvent {
pub _runtime: PhantomData,
pub block_height: BitcoinBlockHeight,
pub block_header_hash: T::H256Le,
+ pub account_id: T::AccountId,
}
#[derive(Clone, Debug, Eq, PartialEq, Event, Decode)]
@@ -68,6 +69,7 @@ pub struct StoreMainChainHeaderEvent {
pub _runtime: PhantomData,
pub block_height: BitcoinBlockHeight,
pub block_header_hash: T::H256Le,
+ pub account_id: T::AccountId,
}
#[derive(Clone, Debug, Eq, PartialEq, Store, Encode)]
diff --git a/runtime/src/pallets/mod.rs b/runtime/src/pallets/mod.rs
index ab45e106b..cd9cb5f81 100644
--- a/runtime/src/pallets/mod.rs
+++ b/runtime/src/pallets/mod.rs
@@ -15,10 +15,14 @@ pub mod timestamp;
pub mod treasury;
pub mod vault_registry;
-pub use btc_relay::{
- BitcoinBlockHeight, BtcAddress, BtcPublicKey, H256Le, RawBlockHeader, RichBlockHeader,
-};
+pub use btc_relay::{BitcoinBlockHeight, BtcAddress, BtcPublicKey, H256Le, RawBlockHeader, RichBlockHeader};
+pub use issue::{IssueRequest, RequestIssueEvent};
+pub use redeem::RedeemRequest;
+pub use refund::RefundRequest;
+pub use replace::ReplaceRequest;
pub use security::{ErrorCode, StatusCode};
+pub use staked_relayers::StatusUpdate;
+pub use vault_registry::{Vault, VaultStatus};
use parity_scale_codec::{Codec, EncodeLike};
use sp_arithmetic::traits::Saturating;
@@ -44,4 +48,11 @@ pub trait Core: System {
type StatusUpdateId: Codec + EncodeLike + Member + Default;
type SignedFixedPoint: Codec + EncodeLike + Member + Default;
type UnsignedFixedPoint: Codec + EncodeLike + Member + Default;
+ type VaultStatus: Codec + EncodeLike + Default + Send + Sync;
+
+ // cumulus / polkadot types
+ type XcmError: Codec + EncodeLike + Member;
+ type NetworkId: Codec + EncodeLike + Member;
+ type RelayChainBlockNumber: Codec + EncodeLike + Member + Default;
+ type ParaId: Codec + EncodeLike + Member + Default;
}
diff --git a/runtime/src/pallets/redeem.rs b/runtime/src/pallets/redeem.rs
index 120907184..aefa925db 100644
--- a/runtime/src/pallets/redeem.rs
+++ b/runtime/src/pallets/redeem.rs
@@ -68,8 +68,14 @@ pub struct RedeemRequestsStore {
pub redeem_id: T::H256,
}
+#[derive(Clone, Debug, Eq, PartialEq, Store, Encode)]
+pub struct RedeemPeriodStore {
+ #[store(returns = T::BlockNumber)]
+ pub _runtime: PhantomData,
+}
+
#[derive(Clone, Debug, PartialEq, Call, Encode)]
pub struct SetRedeemPeriodCall {
- pub period: u32,
+ pub period: T::BlockNumber,
pub _runtime: PhantomData,
}
diff --git a/runtime/src/pallets/replace.rs b/runtime/src/pallets/replace.rs
index f5c0d6f12..1cb14692f 100644
--- a/runtime/src/pallets/replace.rs
+++ b/runtime/src/pallets/replace.rs
@@ -103,7 +103,7 @@ pub struct CancelReplaceEvent {
#[derive(Clone, Debug, Eq, PartialEq, Store, Encode)]
pub struct ReplacePeriodStore {
- #[store(returns = u32)]
+ #[store(returns = T::BlockNumber)]
pub _runtime: PhantomData,
}
@@ -116,6 +116,6 @@ pub struct ReplaceRequestsStore {
#[derive(Clone, Debug, PartialEq, Call, Encode)]
pub struct SetReplacePeriodCall {
- pub period: u32,
+ pub period: T::BlockNumber,
pub _runtime: PhantomData,
}
diff --git a/runtime/src/pallets/sla.rs b/runtime/src/pallets/sla.rs
index a786b02ad..191860126 100644
--- a/runtime/src/pallets/sla.rs
+++ b/runtime/src/pallets/sla.rs
@@ -11,10 +11,12 @@ pub trait Sla: Core {}
pub struct UpdateVaultSLAEvent {
pub vault_id: T::AccountId,
pub new_sla: T::SignedFixedPoint,
+ pub delta_sla: T::SignedFixedPoint,
}
#[derive(Clone, Debug, Eq, PartialEq, Event, Decode, Serialize)]
pub struct UpdateRelayerSLAEvent {
pub relayer_id: T::AccountId,
pub new_sla: T::SignedFixedPoint,
+ pub delta_sla: T::SignedFixedPoint,
}
diff --git a/runtime/src/pallets/staked_relayers.rs b/runtime/src/pallets/staked_relayers.rs
index cfc84d375..31368cee4 100644
--- a/runtime/src/pallets/staked_relayers.rs
+++ b/runtime/src/pallets/staked_relayers.rs
@@ -1,7 +1,9 @@
use super::Core;
use core::marker::PhantomData;
-pub use module_staked_relayers::types::{StakedRelayer, StatusUpdate};
-pub use module_staked_relayers::Error as StakedRelayersError;
+pub use module_staked_relayers::{
+ types::{StakedRelayer, StatusUpdate},
+ Error as StakedRelayersError,
+};
use parity_scale_codec::{Decode, Encode};
use std::fmt::Debug;
use substrate_subxt::balances::Balances;
diff --git a/runtime/src/pallets/vault_registry.rs b/runtime/src/pallets/vault_registry.rs
index f207e67a8..14290d87d 100644
--- a/runtime/src/pallets/vault_registry.rs
+++ b/runtime/src/pallets/vault_registry.rs
@@ -47,7 +47,7 @@ pub struct WithdrawCollateralEvent {
#[derive(Clone, Debug, Eq, PartialEq, Store, Encode)]
pub struct VaultsStore {
- #[store(returns = Vault)]
+ #[store(returns = Vault)]
pub _runtime: PhantomData,
pub account_id: T::AccountId,
}
diff --git a/runtime/src/rpc.rs b/runtime/src/rpc.rs
index 2d5554002..6821a323e 100644
--- a/runtime/src/rpc.rs
+++ b/runtime/src/rpc.rs
@@ -2,104 +2,50 @@ pub use module_exchange_rate_oracle::BtcTxFeesPerByte;
use async_trait::async_trait;
use core::marker::PhantomData;
-use jsonrpsee::{
- common::{to_value as to_json_value, Params},
- Client as RpcClient,
-};
+use futures::{stream::StreamExt, FutureExt, SinkExt};
+use jsonrpsee_types::jsonrpc::{to_value as to_json_value, Params};
use log::trace;
use module_exchange_rate_oracle_rpc_runtime_api::BalanceWrapper;
use sp_arithmetic::FixedU128;
-use sp_core::sr25519::Pair as KeyPair;
use sp_core::H256;
-use std::collections::BTreeSet;
-use std::future::Future;
-use std::sync::Arc;
-use std::time::Duration;
-use substrate_subxt::Error as XtError;
+use std::{collections::BTreeSet, future::Future, sync::Arc, time::Duration};
use substrate_subxt::{
- sudo::*, system::System, Call, Client, ClientBuilder, Event, EventSubscription, EventsDecoder,
- PairSigner, Signer,
+ sudo::*, Call, Client as SubxtClient, ClientBuilder as SubxtClientBuilder, Error as XtError, Event,
+ EventSubscription, EventTypeRegistry, EventsDecoder, RpcClient, Signer,
+};
+use tokio::{sync::RwLock, time::delay_for};
+
+use crate::{
+ balances_dot::*, btc_relay::*, conn::*, exchange_rate_oracle::*, fee::*, issue::*, pallets::Core, redeem::*,
+ refund::*, replace::*, security::*, staked_relayers::*, timestamp::*, types::*, vault_registry::*, BlockNumber,
+ Error, PolkaBtcRuntime,
};
-use tokio::sync::RwLock;
-use tokio::time::delay_for;
-
-use crate::balances_dot::*;
-use crate::btc_relay::*;
-use crate::exchange_rate_oracle::*;
-use crate::fee::*;
-use crate::issue::*;
-use crate::pallets::Core;
-use crate::redeem::*;
-use crate::refund::*;
-use crate::replace::*;
-use crate::security::*;
-use crate::staked_relayers::*;
-use crate::timestamp::*;
-use crate::vault_registry::*;
-use crate::Error;
-use crate::PolkaBtcRuntime;
-use futures::{stream::StreamExt, SinkExt};
-use substrate_subxt::EventTypeRegistry;
-
-pub type PolkaBtcHeader = ::Header;
-
-pub type AccountId = ::AccountId;
-
-pub type PolkaBtcVault =
- Vault::BlockNumber, ::PolkaBTC>;
-
-pub type PolkaBtcIssueRequest = IssueRequest<
- AccountId,
- ::BlockNumber,
- ::PolkaBTC,
- ::DOT,
->;
-pub type PolkaBtcRequestIssueEvent = RequestIssueEvent;
-
-pub type PolkaBtcRedeemRequest = RedeemRequest<
- AccountId,
- ::BlockNumber,
- ::PolkaBTC,
- ::DOT,
->;
-
-pub type PolkaBtcRefundRequest = RefundRequest::PolkaBTC>;
-
-pub type PolkaBtcReplaceRequest = ReplaceRequest<
- AccountId,
- ::BlockNumber,
- ::PolkaBTC,
- ::DOT,
->;
-
-pub type PolkaBtcStatusUpdate = StatusUpdate<
- AccountId,
- ::BlockNumber,
- ::DOT,
->;
#[derive(Clone)]
pub struct PolkaBtcProvider {
rpc_client: RpcClient,
- ext_client: Client,
- signer: Arc>>,
+ ext_client: SubxtClient,
+ signer: Arc