Struct serai_processor::networks::bitcoin::Bitcoin

pub struct Bitcoin { /* private fields */ }

Implementations

impl Bitcoin

pub async fn new(url: String) -> Bitcoin

Trait Implementations

impl Block<Bitcoin> for Block

type Id = [u8; 32]

fn id(&self) -> Self::Id

fn parent(&self) -> Self::Id

fn time<'life0, 'life1, 'async_trait>( &'life0 self, rpc: &'life1 Bitcoin, ) -> Pin<Box<dyn Future<Output = u64> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The monotonic network time at this block.

impl Clone for Bitcoin

fn clone(&self) -> Bitcoin

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Bitcoin

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Network for Bitcoin

type Curve = Secp256k1

The elliptic curve used for this network.

type Transaction = Transaction

The type representing the transaction for this network.

type Block = Block

The type representing the block for this network.

type Output = Output

The type containing all information on a scanned output.

type SignableTransaction = SignableTransaction

The type containing all information on a planned transaction, waiting to be signed.

type Eventuality = Eventuality

The type containing all information to check if a plan was completed.

type TransactionMachine = TransactionMachine

The FROST machine to sign a transaction.

type Scheduler = Scheduler<Bitcoin>

The scheduler for this network.

type Address = Address

The type representing an address.

const NETWORK: ExternalNetworkId = ExternalNetworkId::Bitcoin

Network ID for this network.

const ID: &'static str = "Bitcoin"

String ID for this network.

const ESTIMATED_BLOCK_TIME_IN_SECONDS: usize = 600usize

The estimated amount of time a block will take.

const CONFIRMATIONS: usize = 6usize

The amount of confirmations required to consider a block ‘final’.

const DUST: u64 = 10_000u64

Minimum output value which will be handled.

const COST_TO_AGGREGATE: u64 = 800u64

The cost to perform input aggregation with a 2-input 1-output TX.

const MAX_OUTPUTS: usize = 520usize

The maximum amount of outputs which will fit in a TX. This should be equal to MAX_INPUTS unless one is specifically limited. A TX with MAX_INPUTS and MAX_OUTPUTS must not exceed the max size.

fn tweak_keys(keys: &mut ThresholdKeys<Self::Curve>)

Tweak keys for this network.

fn branch_address(key: ProjectivePoint) -> Option<Address>

Address for the given group key to use for scheduled branches.

fn change_address(key: ProjectivePoint) -> Option<Address>

Address for the given group key to use for change.

fn forward_address(key: ProjectivePoint) -> Option<Address>

Address for forwarded outputs from prior multisigs.

fn get_latest_block_number<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<usize, NetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the latest block’s number.

fn get_block<'life0, 'async_trait>( &'life0 self, number: usize, ) -> Pin<Box<dyn Future<Output = Result<Self::Block, NetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get a block by its number.

fn get_outputs<'life0, 'life1, 'async_trait>( &'life0 self, block: &'life1 Self::Block, key: ProjectivePoint, ) -> Pin<Box<dyn Future<Output = Vec<Output>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the outputs within a block for a specific key.

fn get_eventuality_completions<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, eventualities: &'life1 mut EventualitiesTracker<Eventuality>, block: &'life2 Self::Block, ) -> Pin<Box<dyn Future<Output = HashMap<[u8; 32], (usize, [u8; 32], Transaction)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get the registered eventualities completed within this block, and any prior blocks which registered eventualities may have been completed in.

fn needed_fee<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, block_number: usize, inputs: &'life1 [Output], payments: &'life2 [Payment<Self>], change: &'life3 Option<Address>, ) -> Pin<Box<dyn Future<Output = Result<Option<u64>, NetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Returns the needed fee to fulfill this Plan at this fee rate.

fn signable_transaction<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, block_number: usize, _plan_id: &'life1 [u8; 32], _key: ProjectivePoint, inputs: &'life2 [Output], payments: &'life3 [Payment<Self>], change: &'life4 Option<Address>, (): &'life5 (), ) -> Pin<Box<dyn Future<Output = Result<Option<(Self::SignableTransaction, Self::Eventuality)>, NetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Create a SignableTransaction for the given Plan.

fn attempt_sign<'life0, 'async_trait>( &'life0 self, keys: ThresholdKeys<Self::Curve>, transaction: Self::SignableTransaction, ) -> Pin<Box<dyn Future<Output = Result<Self::TransactionMachine, NetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Attempt to sign a SignableTransaction.

fn publish_completion<'life0, 'life1, 'async_trait>( &'life0 self, tx: &'life1 Transaction, ) -> Pin<Box<dyn Future<Output = Result<(), NetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Publish a completion.

fn confirm_completion<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, eventuality: &'life1 Self::Eventuality, _: &'life2 EmptyClaim, ) -> Pin<Box<dyn Future<Output = Result<Option<Transaction>, NetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Confirm a plan was completed by the specified transaction, per our bounds.

fn get_latest_block_number_with_retries<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = usize> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the latest block’s number, retrying until success.

fn get_block_with_retries<'life0, 'async_trait>( &'life0 self, block_number: usize, ) -> Pin<Box<dyn Future<Output = Self::Block> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get a block, retrying until success.

fn prepare_send<'life0, 'async_trait>( &'life0 self, block_number: usize, plan: Plan<Self>, operating_costs: u64, ) -> Pin<Box<dyn Future<Output = Result<PreparedSend<Self>, NetworkError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Prepare a SignableTransaction for a transaction.

impl Output<Bitcoin> for Output

type Id = OutputId

fn kind(&self) -> OutputType

fn id(&self) -> Self::Id

fn tx_id(&self) -> [u8; 32]

fn key(&self) -> ProjectivePoint

fn presumed_origin(&self) -> Option<Address>

fn balance(&self) -> ExternalBalance

fn data(&self) -> &[u8]

fn write<W: Write>(&self, writer: &mut W) -> Result<()>

fn read<R: Read>(reader: &mut R) -> Result<Self>

impl PartialEq for Bitcoin

fn eq(&self, _: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Transaction<Bitcoin> for Transaction

type Id = [u8; 32]

fn id(&self) -> Self::Id

impl UtxoNetwork for Bitcoin

const MAX_INPUTS: usize = 520usize

The maximum amount of inputs which will fit in a TX. This should be equal to MAX_OUTPUTS unless one is specifically limited. A TX with MAX_INPUTS and MAX_OUTPUTS must not exceed the max size.

impl Eq for Bitcoin