Struct runtime::InterBtcParachain

pub struct InterBtcParachain {
    pub native_currency_id: CurrencyId,
    pub relay_chain_currency_id: CurrencyId,
    pub wrapped_currency_id: CurrencyId,
    /* private fields */
}

Fields

native_currency_id: CurrencyId

relay_chain_currency_id: CurrencyId

wrapped_currency_id: CurrencyId

Implementations

impl InterBtcParachain

pub async fn new<P: RpcClientT>( rpc_client: P, signer: InterBtcSigner, shutdown_tx: ShutdownSender ) -> Result<Self, Error>

pub async fn from_url( url: &str, signer: InterBtcSigner, shutdown_tx: ShutdownSender ) -> Result<Self, Error>

pub async fn from_url_with_retry( url: &str, signer: InterBtcSigner, connection_timeout: Duration, shutdown_tx: ShutdownSender ) -> Result<Self, Error>

pub async fn from_url_and_config_with_retry( url: &str, signer: InterBtcSigner, max_concurrent_requests: Option<usize>, max_notifs_per_subscription: Option<usize>, connection_timeout: Duration, shutdown_tx: ShutdownSender ) -> Result<Self, Error>

pub async fn get_finalized_block_hash(&self) -> Result<H256, Error>

pub async fn on_block<F, R>(&self, on_block: F) -> Result<(), Error>where F: Fn(InterBtcHeader) -> R, R: Future<Output = Result<(), Error>>,

Subscribe to new parachain blocks.

pub async fn wait_for_block(&self, height: u32) -> Result<(), Error>

Wait for the block at the given height Note: will always wait at least one block.

pub async fn delay_for_blocks(&self, delay: u32) -> Result<(), Error>

Sleep for delay parachain blocks

pub async fn on_event_error<E: Fn(Error)>( &self, on_error: E ) -> Result<(), Error>

Subscription service that should listen forever, only returns if the initial subscription cannot be established. Calls on_error when an error event has been received, or when an event has been received that failed to be decoded into a raw event.

Arguments

• on_error - callback for decoding errors, is not allowed to take too long

pub async fn on_event<T, F, R, E>( &self, on_event: F, on_error: E ) -> Result<(), Error>where T: StaticEvent + Debug, F: FnMut(T) -> R, R: Future<Output = ()>, E: Fn(Error),

Subscription service that should listen forever, only returns if the initial subscription cannot be established. This function uses two concurrent tasks: one for the event listener, and one that calls the given callback. This allows the callback to take a long time to complete without breaking the rpc communication, which could otherwise happen. Still, since the queue of callbacks is processed sequentially, some care should be taken that the queue does not overflow. on_error is called when the event has successfully been decoded into a raw_event, but failed to decode into an event of type T

Arguments

• on_event - callback for events, is allowed to sometimes take a longer time
• on_error - callback for decoding error, is not allowed to take too long

pub async fn store_assets_metadata(&self) -> Result<(), Error>

pub async fn store_lend_tokens(&self) -> Result<(), Error>

pub async fn listen_for_registered_assets(&self) -> Result<(), Error>

Cache registered assets and updates

pub async fn listen_for_lending_markets(&self) -> Result<(), Error>

Cache new markets and updates

pub async fn listen_for_fee_rate_changes(&self) -> Result<(), Error>

Listen to fee_rate changes and broadcast new values on the fee_rate_update_tx channel

Trait Implementations

impl BtcRelayPallet for InterBtcParachain

fn get_best_block<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<H256Le, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get the hash of the current best tip.

fn get_best_block_height<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<u32, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get the current best known height.

fn get_block_hash<'life0, 'async_trait>( &'life0 self, height: u32 ) -> Pin<Box<dyn Future<Output = Result<H256Le, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get the block hash for the main chain at the specified height.

Arguments

• height - chain height

fn get_block_header<'life0, 'async_trait>( &'life0 self, hash: H256Le ) -> Pin<Box<dyn Future<Output = Result<InterBtcRichBlockHeader, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get the corresponding block header for the given hash.

Arguments

• hash - little endian block hash

fn get_bitcoin_confirmations<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<u32, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get the global security parameter k for stable Bitcoin transactions

fn get_parachain_confirmations<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<BlockNumber, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get the global security parameter for stable parachain confirmations

fn wait_for_block_in_relay<'life0, 'async_trait>( &'life0 self, block_hash: H256Le, _btc_confirmations: Option<BlockNumber> ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Wait until Bitcoin block is submitted to the relay

fn verify_block_header_inclusion<'life0, 'async_trait>( &'life0 self, block_hash: H256Le ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

check that the block with the given block is included in the main chain of the relay, with sufficient confirmations

fn initialize_btc_relay<'life0, 'async_trait>( &'life0 self, header: RawBlockHeader, height: BitcoinBlockHeight ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Initializes the relay with the provided block header and height, should be called automatically by relayer subject to the result of is_initialized.

Arguments

• header - raw block header
• height - starting height

fn store_block_header<'life0, 'async_trait>( &'life0 self, header: RawBlockHeader ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Stores a block header in the BTC-Relay.

Arguments

• header - raw block header

fn store_block_headers<'life0, 'async_trait>( &'life0 self, headers: Vec<RawBlockHeader> ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Stores multiple block headers in the BTC-Relay.

Arguments

• headers - raw block headers

impl Clone for InterBtcParachain

fn clone(&self) -> InterBtcParachain

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CollateralBalancesPallet for InterBtcParachain

fn get_free_balance<'life0, 'async_trait>( &'life0 self, currency_id: CurrencyId ) -> Pin<Box<dyn Future<Output = Result<Balance, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn get_free_balance_for_id<'life0, 'async_trait>( &'life0 self, id: AccountId, currency_id: CurrencyId ) -> Pin<Box<dyn Future<Output = Result<Balance, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn get_reserved_balance<'life0, 'async_trait>( &'life0 self, currency_id: CurrencyId ) -> Pin<Box<dyn Future<Output = Result<Balance, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn get_reserved_balance_for_id<'life0, 'async_trait>( &'life0 self, id: AccountId, currency_id: CurrencyId ) -> Pin<Box<dyn Future<Output = Result<Balance, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn transfer_to<'life0, 'life1, 'async_trait>( &'life0 self, recipient: &'life1 AccountId, amounts: Vec<(u128, CurrencyId)> ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl FeePallet for InterBtcParachain

fn get_issue_griefing_collateral<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<FixedU128, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn get_issue_fee<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<FixedU128, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn get_replace_griefing_collateral<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<FixedU128, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

impl IssuePallet for InterBtcParachain

fn request_issue<'life0, 'life1, 'async_trait>( &'life0 self, amount: u128, vault_id: &'life1 VaultId ) -> Pin<Box<dyn Future<Output = Result<RequestIssueEvent, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Request a new issue

fn execute_issue<'life0, 'life1, 'async_trait>( &'life0 self, issue_id: H256, raw_proof: &'life1 RawTransactionProof ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a issue request by providing a Bitcoin transaction inclusion proof

fn cancel_issue<'life0, 'async_trait>( &'life0 self, issue_id: H256 ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Cancel an ongoing issue request

fn get_issue_request<'life0, 'async_trait>( &'life0 self, issue_id: H256 ) -> Pin<Box<dyn Future<Output = Result<InterBtcIssueRequest, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn get_vault_issue_requests<'life0, 'async_trait>( &'life0 self, account_id: AccountId ) -> Pin<Box<dyn Future<Output = Result<Vec<(H256, InterBtcIssueRequest)>, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn get_issue_period<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<u32, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn get_all_active_issues<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Vec<(H256, InterBtcIssueRequest)>, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

impl OraclePallet for InterBtcParachain

fn get_exchange_rate<'life0, 'async_trait>( &'life0 self, currency_id: CurrencyId ) -> Pin<Box<dyn Future<Output = Result<FixedU128, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Returns the last exchange rate in planck per satoshis, the time at which it was set and the configured max delay.

fn feed_values<'life0, 'async_trait>( &'life0 self, values: Vec<(OracleKey, FixedU128)> ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Sets the current exchange rate (i.e. DOT/BTC)

Arguments

• value - the current exchange rate

fn set_bitcoin_fees<'life0, 'async_trait>( &'life0 self, value: FixedU128 ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Sets the estimated Satoshis per bytes required to get a Bitcoin transaction included in in the next block (~10 min)

Arguments

• value - the estimated fee rate

fn get_bitcoin_fees<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<FixedU128, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Gets the estimated Satoshis per bytes required to get a Bitcoin transaction included in in the next x blocks

fn wrapped_to_collateral<'life0, 'async_trait>( &'life0 self, amount: u128, currency_id: CurrencyId ) -> Pin<Box<dyn Future<Output = Result<u128, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Converts the amount in btc to dot, based on the current set exchange rate.

fn collateral_to_wrapped<'life0, 'async_trait>( &'life0 self, amount: u128, currency_id: CurrencyId ) -> Pin<Box<dyn Future<Output = Result<u128, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Converts the amount in dot to btc, based on the current set exchange rate.

fn has_updated<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 OracleKey ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn on_fee_rate_change(&self) -> FeeRateUpdateReceiver

impl RedeemPallet for InterBtcParachain

fn request_redeem<'life0, 'life1, 'async_trait>( &'life0 self, amount: u128, btc_address: BtcAddress, vault_id: &'life1 VaultId ) -> Pin<Box<dyn Future<Output = Result<H256, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Request a new redeem

fn execute_redeem<'life0, 'life1, 'async_trait>( &'life0 self, redeem_id: H256, raw_proof: &'life1 RawTransactionProof ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a redeem request by providing a Bitcoin transaction inclusion proof

fn cancel_redeem<'life0, 'async_trait>( &'life0 self, redeem_id: H256, reimburse: bool ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Cancel an ongoing redeem request

fn get_redeem_request<'life0, 'async_trait>( &'life0 self, redeem_id: H256 ) -> Pin<Box<dyn Future<Output = Result<InterBtcRedeemRequest, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn get_vault_redeem_requests<'life0, 'async_trait>( &'life0 self, account_id: AccountId ) -> Pin<Box<dyn Future<Output = Result<Vec<(H256, InterBtcRedeemRequest)>, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get all redeem requests requested of the given vault

fn get_redeem_period<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<BlockNumber, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

impl ReplacePallet for InterBtcParachain

fn get_new_vault_replace_requests<'life0, 'async_trait>( &'life0 self, account_id: AccountId ) -> Pin<Box<dyn Future<Output = Result<Vec<(H256, InterBtcReplaceRequest)>, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get all replace requests accepted by the given vault

fn get_old_vault_replace_requests<'life0, 'async_trait>( &'life0 self, account_id: AccountId ) -> Pin<Box<dyn Future<Output = Result<Vec<(H256, InterBtcReplaceRequest)>, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get all replace requests made by the given vault

fn request_replace<'life0, 'life1, 'async_trait>( &'life0 self, vault_id: &'life1 VaultId, amount: u128 ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Request the replacement of a new vault ownership

fn withdraw_replace<'life0, 'life1, 'async_trait>( &'life0 self, vault_id: &'life1 VaultId, amount: u128 ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Withdraw a request of vault replacement

fn accept_replace<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, new_vault: &'life1 VaultId, old_vault: &'life2 VaultId, amount_btc: u128, collateral: u128, btc_address: BtcAddress ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Accept request of vault replacement

fn execute_replace<'life0, 'life1, 'async_trait>( &'life0 self, replace_id: H256, raw_proof: &'life1 RawTransactionProof ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute vault replacement

fn cancel_replace<'life0, 'async_trait>( &'life0 self, replace_id: H256 ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Cancel vault replacement

fn get_replace_period<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<u32, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get the time difference in number of blocks between when a replace request is created and required completion time by a vault

fn get_replace_request<'life0, 'async_trait>( &'life0 self, replace_id: H256 ) -> Pin<Box<dyn Future<Output = Result<InterBtcReplaceRequest, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get a replace request from storage

fn get_replace_dust_amount<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<u128, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Gets the minimum btc amount for replace requests

impl SecurityPallet for InterBtcParachain

fn get_current_active_block_number<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<u32, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Gets the current active block number of the parachain

impl SudoPallet for InterBtcParachain

fn set_parachain_confirmations<'life0, 'async_trait>( &'life0 self, value: BlockNumber ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Set the global security parameter for stable parachain confirmations

fn set_bitcoin_confirmations<'life0, 'async_trait>( &'life0 self, value: u32 ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Set the global security parameter k for stable Bitcoin transactions

fn insert_authorized_oracle<'life0, 'async_trait>( &'life0 self, account_id: AccountId, name: String ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Adds a new authorized oracle with the given name and the signer’s AccountId

Arguments

• account_id - The Account ID of the new oracle
• name - The name of the new oracle

fn sudo<'life0, 'async_trait>( &'life0 self, call: EncodedCall ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn set_storage<'life0, 'life1, 'life2, 'async_trait, V>( &'life0 self, module: &'life1 str, key: &'life2 str, value: V ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where V: 'async_trait + Encode + Send + Sync, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn set_redeem_period<'life0, 'async_trait>( &'life0 self, period: BlockNumber ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn disable_difficulty_check<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn set_issue_period<'life0, 'async_trait>( &'life0 self, period: u32 ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn set_replace_period<'life0, 'async_trait>( &'life0 self, period: u32 ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn set_balances<'life0, 'async_trait>( &'life0 self, amounts: Vec<(AccountId, u128, u128, CurrencyId)> ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

impl TimestampPallet for InterBtcParachain

fn get_time_now<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get the current time as defined by the timestamp pallet.

impl UtilFuncs for InterBtcParachain

fn get_current_chain_height<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<u32, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Gets the current height of the parachain

fn get_rpc_properties<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Map<String, Value>, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn get_native_currency_id(&self) -> CurrencyId

Gets the ID of the native currency.

fn get_account_id(&self) -> &AccountId

Get the address of the configured signer.

fn is_this_vault(&self, vault_id: &VaultId) -> bool

fn get_foreign_assets_metadata<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Vec<(u32, AssetMetadata)>, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn get_lend_tokens<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Vec<(CurrencyId, CurrencyId)>, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn get_foreign_asset_metadata<'life0, 'async_trait>( &'life0 self, id: u32 ) -> Pin<Box<dyn Future<Output = Result<AssetMetadata, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

impl VaultRegistryPallet for InterBtcParachain

fn get_vault<'life0, 'life1, 'async_trait>( &'life0 self, vault_id: &'life1 VaultId ) -> Pin<Box<dyn Future<Output = Result<InterBtcVault, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch a specific vault by ID.

Arguments

• vault_id - account ID of the vault

Errors

• VaultNotFound - if the rpc returned a default value rather than the vault we want
• VaultLiquidated - if the vault is liquidated

fn get_all_vaults<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Vec<InterBtcVault>, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Fetch all active vaults.

fn register_vault<'life0, 'life1, 'async_trait>( &'life0 self, vault_id: &'life1 VaultId, collateral: u128 ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Submit extrinsic to register a vault.

Arguments

• collateral - deposit
• public_key - Bitcoin public key

fn deposit_collateral<'life0, 'life1, 'async_trait>( &'life0 self, vault_id: &'life1 VaultId, amount: u128 ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Locks additional collateral as a security against stealing the Bitcoin locked with it.

Arguments

• amount - the amount of extra collateral to lock

fn withdraw_collateral<'life0, 'life1, 'async_trait>( &'life0 self, vault_id: &'life1 VaultId, amount: u128 ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Withdraws amount of the collateral from the amount locked by the vault corresponding to the origin account The collateral left after withdrawal must be more than MinimumCollateralVault and above the SecureCollateralThreshold. Collateral that is currently being used to back issued tokens remains locked until the Vault is used for a redeem request (full release can take multiple redeem requests).

Arguments

• amount - the amount of collateral to withdraw

fn register_public_key<'life0, 'async_trait>( &'life0 self, public_key: BtcPublicKey ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Update the default BTC public key for the vault corresponding to the signer.

Arguments

• public_key - the new public key of the vault

fn get_required_collateral_for_wrapped<'life0, 'async_trait>( &'life0 self, amount_btc: u128, collateral_currency: CurrencyId ) -> Pin<Box<dyn Future<Output = Result<u128, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Custom RPC that calculates the exact collateral required to cover the BTC amount.

Arguments

• amount_btc - amount of btc to cover

fn get_required_collateral_for_vault<'life0, 'async_trait>( &'life0 self, vault_id: VaultId ) -> Pin<Box<dyn Future<Output = Result<u128, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get the amount of collateral required for the given vault to be at the current SecureCollateralThreshold with the current exchange rate

fn set_current_client_release<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, uri: &'life1 [u8], checksum: &'life2 H256 ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

For testing purposes only. Sets the current vault client release.

Arguments

• uri - URI to the client release binary
• checksum - The SHA256 checksum of the client binary

fn set_pending_client_release<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, uri: &'life1 [u8], checksum: &'life2 H256 ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

For testing purposes only. Sets the pending vault client release.

Arguments

• uri - URI to the client release binary
• checksum - The SHA256 checksum of the client binary

fn get_vaults_by_account_id<'life0, 'life1, 'async_trait>( &'life0 self, account_id: &'life1 AccountId ) -> Pin<Box<dyn Future<Output = Result<Vec<VaultId>, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_public_key<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Option<BtcPublicKey>, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn get_vault_total_collateral<'life0, 'async_trait>( &'life0 self, vault_id: VaultId ) -> Pin<Box<dyn Future<Output = Result<u128, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn get_collateralization_from_vault<'life0, 'async_trait>( &'life0 self, vault_id: VaultId, only_issued: bool ) -> Pin<Box<dyn Future<Output = Result<u128, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,