Struct raiden_api::api::Api

pub struct Api {
    pub raiden: Arc<Raiden>,
    /* private fields */
}

The interface which enables initiating payments and interacting with contracts.

Fields

raiden: Arc<Raiden>

Implementations

impl Api

pub fn new( raiden: Arc<Raiden>, transition_service: Arc<Transitioner>, payments_registry: Arc<RwLock<PaymentsRegistry>> ) -> Self

Creates a new instance of Api

pub async fn create_channel( &self, account: Account<Http>, registry_address: Address, token_address: TokenAddress, partner_address: Address, settle_timeout: Option<SettleTimeout>, reveal_timeout: Option<RevealTimeout>, retry_timeout: Option<RetryTimeout> ) -> Result<ChannelIdentifier, ApiError>

Creates a new channel with the current account being one participant.

pub async fn update_channel( &self, account: Account<Http>, registry_address: Address, token_address: TokenAddress, partner_address: Address, reveal_timeout: Option<RevealTimeout>, total_deposit: Option<TokenAmount>, total_withdraw: Option<TokenAmount>, state: Option<ChannelStatus>, retry_timeout: Option<RetryTimeout> ) -> Result<(), ApiError>

Updates a channel state on-chain depending on the parameters passed.

Only one optional parameter is allowed to be set in a single call to determine what the call will do.

reveal_timeout: Sets the reveal timeout of a channel. total_deposit: Deposit the defined amount into the channel. total_withdraw: Initiates a withdraw with partner. state: Alters the state of the channel. For example: closed.

pub async fn channel_deposit( &self, account: Account<Http>, channel_state: &ChannelState, total_deposit: TokenAmount, retry_timeout: Option<RetryTimeout> ) -> Result<(), ApiError>

pub async fn channel_withdraw( &self, channel_state: &ChannelState, total_withdraw: TokenAmount ) -> Result<(), ApiError>

Initiate a withdraw from channel’s balance.

pub async fn channel_reveal_timeout( &self, channel_state: &ChannelState, reveal_timeout: RevealTimeout ) -> Result<(), ApiError>

Set the channel’s reveal timeout.

pub async fn channel_close( &self, registry_address: Address, channel_state: &ChannelState ) -> Result<(), ApiError>

Close a channel.

pub async fn token_network_register( &self, registry_address: Address, token_address: TokenAddress ) -> Result<TokenNetworkAddress, ApiError>

Register a new token network.

pub async fn token_network_leave( &self, registry_address: Address, token_address: TokenAddress ) -> Result<Vec<ChannelState>, ApiError>

Leave token network by token address.

pub async fn channel_batch_close( &self, registry_address: Address, token_address: TokenAddress, partners: Vec<Address>, retry_timeout: Option<RetryTimeout>, coop_settle: bool ) -> Result<(), ApiError>

Batch close channels.

This will attempt to cooperatively settle a channel and then close it.

pub async fn batch_coop_settle( &self, channels: Vec<&ChannelState>, retry_timeout: Option<RetryTimeout> ) -> Result<Vec<ChannelState>, ApiError>

Batch cooperative settle

pub async fn deposit_to_udc( &self, user_deposit_address: Address, new_total_deposit: TokenAmount ) -> Result<(), ApiError>

Deposit some amount to the UserDeposit contract.

pub async fn plan_withdraw_from_udc( &self, user_deposit_address: Address, planned_withdraw_amount: TokenAmount ) -> Result<(), ApiError>

Register desire to withdraw from the UserDeposit contract.

The amount stated will be withdrawable after certain blocks have passed.

pub async fn withdraw_from_udc( &self, user_deposit_address: Address, withdraw_amount: TokenAmount ) -> Result<(), ApiError>

Actually perform the previously planned withdraw from the UserDeposit contract.

pub async fn initiate_payment( &self, account: Account<Http>, token_network_registry_address: TokenNetworkRegistryAddress, secret_registry_address: SecretRegistryAddress, token_address: TokenAddress, partner_address: Address, amount: TokenAmount, payment_identifier: Option<PaymentIdentifier>, secret: Option<String>, secret_hash: Option<SecretHash>, lock_timeout: Option<BlockTimeout> ) -> Result<Payment, ApiError>

Initiate a payment to partner.

pub async fn mint_token_for( &self, token_address: TokenAddress, to: Address, value: TokenAmount ) -> Result<TransactionHash, ApiError>

Mint a certain amount of tokens to a specific address.