Struct StateChannel 

pub struct StateChannel {
    pub channel_id: String,
    pub config: StateChannelConfig,
    pub state: ChannelState,
    pub balance_a: u64,
    pub balance_b: u64,
    pub pubkey_a: String,
    pub pubkey_b: String,
    pub version: u64,
    pub updates: Vec<StateUpdate>,
    pub transactions: HashMap<String, Vec<u8>>,
}

State channel

Fields

channel_id: String

Channel ID

config: StateChannelConfig

Configuration

state: ChannelState

Current state

balance_a: u64

Current balance A

balance_b: u64

Current balance B

pubkey_a: String

Public key A

pubkey_b: String

Public key B

version: u64

State version

updates: Vec<StateUpdate>

State updates history

transactions: HashMap<String, Vec<u8>>

Channel transactions

Implementations

impl StateChannel

pub fn new( config: StateChannelConfig, pubkey_a: &str, pubkey_b: &str, initial_balance_a: u64, initial_balance_b: u64, ) -> Result<Self, Box<dyn Error + Send + Sync>>

Create a new state channel

pub fn new_default() -> Self

Create a new state channel with default configuration

impl StateChannel

pub fn open(&mut self) -> Result<String, Box<dyn Error + Send + Sync>>

Open the state channel (create funding transaction)

pub fn update_state( &mut self, balance_a: u64, balance_b: u64, signatures: Vec<String>, ) -> Result<StateUpdate, Box<dyn Error + Send + Sync>>

Update the state channel

pub fn close_cooperative( &mut self, ) -> Result<String, Box<dyn Error + Send + Sync>>

Close the state channel (cooperative close)

pub fn force_close(&mut self) -> Result<String, Box<dyn Error + Send + Sync>>

Force close the state channel (unilateral close)

pub fn get_latest_update(&self) -> Option<&StateUpdate>

Get the latest state update

pub fn get_update_by_version(&self, version: u64) -> Option<&StateUpdate>

Get state update by version

pub fn get_transaction(&self, tx_id: &str) -> Option<&Vec<u8>>

Get transaction by ID

Trait Implementations

impl Debug for StateChannel

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

Formats the value using the given formatter.

impl Default for StateChannel

fn default() -> Self

Returns the “default value” for a type.

impl Layer2Protocol for StateChannel

Implementation of async Layer2Protocol trait for StateChannel

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

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

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

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

fn get_state<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<ProtocolState, Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

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

fn submit_transaction<'life0, 'life1, 'async_trait>( &'life0 self, tx_data: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<String, Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

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

fn check_transaction_status<'life0, 'life1, 'async_trait>( &'life0 self, tx_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<TransactionStatus, Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

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

fn sync_state<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

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

fn issue_asset<'life0, 'async_trait>( &'life0 self, params: AssetParams, ) -> Pin<Box<dyn Future<Output = Result<String, Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

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

fn transfer_asset<'life0, 'async_trait>( &'life0 self, transfer: AssetTransfer, ) -> Pin<Box<dyn Future<Output = Result<TransferResult, Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

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

fn verify_proof<'life0, 'async_trait>( &'life0 self, proof: Proof, ) -> Pin<Box<dyn Future<Output = Result<VerificationResult, Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

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

fn validate_state<'life0, 'life1, 'async_trait>( &'life0 self, state_data: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<ValidationResult, Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

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

impl Layer2ProtocolTrait for StateChannel

fn initialize(&self) -> Result<(), Box<dyn Error + Send + Sync>>

fn get_state(&self) -> Result<ProtocolState, Box<dyn Error + Send + Sync>>

fn submit_transaction( &self, tx_data: &[u8], ) -> Result<String, Box<dyn Error + Send + Sync>>

fn check_transaction_status( &self, tx_id: &str, ) -> Result<TransactionStatus, Box<dyn Error + Send + Sync>>

fn sync_state(&mut self) -> Result<(), Box<dyn Error + Send + Sync>>

fn issue_asset( &self, _params: AssetParams, ) -> Result<String, Box<dyn Error + Send + Sync>>

fn transfer_asset( &self, _transfer: AssetTransfer, ) -> Result<TransferResult, Box<dyn Error + Send + Sync>>

fn verify_proof( &self, proof: Proof, ) -> Result<VerificationResult, Box<dyn Error + Send + Sync>>

fn validate_state( &self, _state_data: &[u8], ) -> Result<ValidationResult, Box<dyn Error + Send + Sync>>