Struct DummyClientModule

pub struct DummyClientModule {
    pub(crate) cfg: DummyClientConfig,
    pub(crate) key: Keypair,
    pub(crate) notifier: ModuleNotifier<DummyStateMachine>,
    pub(crate) client_ctx: ClientContext<Self>,
    pub(crate) db: Database,
}

Fields

cfg: DummyClientConfig

key: Keypair

notifier: ModuleNotifier<DummyStateMachine>

client_ctx: ClientContext<Self>

db: Database

Implementations

impl DummyClientModule

pub async fn print_using_account( &self, amount: Amount, account_kp: Keypair, ) -> Result<(OperationId, OutPoint)>

pub async fn print_money( &self, amount: Amount, ) -> Result<(OperationId, OutPoint)>

Request the federation prints money for us

pub async fn print_liability( &self, amount: Amount, ) -> Result<(OperationId, OutPoint)>

Use a broken printer to print a liability instead of money If the federation is honest, should always fail

pub async fn send_money( &self, account: PublicKey, amount: Amount, ) -> Result<OutPoint>

Send money to another user

pub async fn receive_money(&self, outpoint: OutPoint) -> Result<()>

Wait to receive money at an outpoint

pub fn account(&self) -> PublicKey

Return our account

Trait Implementations

impl ClientModule for DummyClientModule

type Init = DummyClientInit

type Common = DummyModuleTypes

Common module types shared between client and server

type Backup = NoModuleBackup

Data stored in regular backups so that restoring doesn’t have to start from epoch 0

type ModuleStateMachineContext = DummyClientContext

Data and API clients available to state machine transitions of this module

type States = DummyStateMachine

All possible states this client can submit to the executor

fn context(&self) -> Self::ModuleStateMachineContext

fn input_fee( &self, _amount: Amount, _input: &<Self::Common as ModuleCommon>::Input, ) -> Option<Amount>

Returns the fee the processing of this input requires.

fn output_fee( &self, _amount: Amount, _output: &<Self::Common as ModuleCommon>::Output, ) -> Option<Amount>

Returns the fee the processing of this output requires.

fn supports_being_primary(&self) -> bool

Does this module support being a primary module

fn create_final_inputs_and_outputs<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, operation_id: OperationId, input_amount: Amount, output_amount: Amount, ) -> Pin<Box<dyn Future<Output = Result<(ClientInputBundle<DummyInput, DummyStateMachine>, ClientOutputBundle<DummyOutput, DummyStateMachine>)>> + Send + 'async_trait>>

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

Creates all inputs and outputs necessary to balance the transaction. The function returns an error if and only if the client’s funds are not sufficient to create the inputs necessary to fully fund the transaction.

fn await_primary_module_output<'life0, 'async_trait>( &'life0 self, operation_id: OperationId, out_point: OutPoint, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Waits for the funds from an output created by Self::create_final_inputs_and_outputs to become available. This function returning typically implies a change in the output of Self::get_balance.

fn get_balance<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dbtc: &'life1 mut DatabaseTransaction<'life2>, ) -> Pin<Box<dyn Future<Output = Amount> + Send + 'async_trait>>

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

Returns the balance held by this module and available for funding transactions.

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

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

Returns a stream that will output the updated module balance each time it changes.

fn decoder() -> Decoder

fn kind() -> ModuleKind

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

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Initialize client.

fn handle_cli_command<'life0, 'life1, 'async_trait>( &'life0 self, _args: &'life1 [OsString], ) -> Pin<Box<dyn Future<Output = Result<Value, Error>> + Send + 'async_trait>>

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

fn handle_rpc<'life0, 'async_trait>( &'life0 self, _method: String, _request: Value, ) -> Pin<Box<dyn Future<Output = Pin<Box<dyn Stream<Item = Result<Value, Error>> + Send + 'life0>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

fn supports_backup(&self) -> bool

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

where 'life0: 'async_trait, Self: Sync + 'async_trait,

fn leave<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _dbtx: &'life1 mut DatabaseTransaction<'life2>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Leave the federation

impl Debug for DummyClientModule

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

Formats the value using the given formatter.