Struct private_tx::Provider

pub struct Provider { /* fields omitted */ }

Manager of private transactions

Implementations

impl Provider

pub fn new(
    client: Arc<Client>,
    miner: Arc<Miner>,
    accounts: Arc<dyn Signer>,
    encryptor: Box<dyn Encryptor>,
    config: ProviderConfig,
    channel: IoChannel<ClientIoMessage<Client>>,
    keys_provider: Arc<dyn KeyProvider>,
    db: Arc<dyn KeyValueDB>
) -> Self

Create a new provider.

pub fn private_state_db(&self) -> Arc<PrivateStateDB>

Returns private state DB

pub fn add_notify(&self, target: Arc<dyn ChainNotify>)

Adds an actor to be notified on certain events

pub fn create_private_transaction(
    &self,
    signed_transaction: SignedTransaction
) -> Result<Receipt, Error>

1. Create private transaction from the signed transaction
2. Executes private transaction
3. Save it with state returned on prev step to the queue for signing
4. Broadcast corresponding message to the chain

pub fn calculate_state_hash(&self, state: &Bytes, nonce: U256) -> H256

Calculate hash from united private state and contract nonce

pub fn process_signature(
    &self,
    signed_tx: &SignedPrivateTransaction
) -> Result<(), Error>

Add signed private transaction into the store Creates corresponding public transaction if last required signature collected and sends it to the chain

pub fn get_contract_nonce(
    &self,
    address: &Address,
    block: BlockId
) -> Result<U256, Error>

pub fn execute_private<T, V>(
    &self,
    transaction: &SignedTransaction,
    options: TransactOptions<T, V>,
    block: BlockId
) -> Result<PrivateExecutionResult<T, V>, Error> where
    T: Tracer,
    V: VMTracer, 

pub fn contract_key_id(&self, contract_address: &Address) -> Result<H256, Error>

Returns the key from the key server associated with the contract

pub fn public_creation_transaction(
    &self,
    block: BlockId,
    source: &SignedTransaction,
    validators: &[Address],
    gas_price: U256
) -> Result<(Transaction, Address), Error>

Create encrypted public contract deployment transaction.

pub fn execute_private_transaction(
    &self,
    block: BlockId,
    source: &SignedTransaction
) -> Result<Bytes, Error>

Create encrypted public contract deployment transaction. Returns updated encrypted state.

pub fn public_transaction(
    &self,
    state: Bytes,
    source: &SignedTransaction,
    signatures: &[Signature],
    nonce: U256,
    gas_price: U256
) -> Result<Transaction, Error>

Create encrypted public transaction from private transaction.

pub fn private_call(
    &self,
    block: BlockId,
    transaction: &SignedTransaction
) -> Result<FlatExecuted, Error>

Call into private contract.

pub fn private_log(&self, tx_hash: H256) -> Result<TransactionLog, Error>

Retrieves log information about private transaction

pub fn get_validators(
    &self,
    block: BlockId,
    address: &Address
) -> Result<Vec<Address>, Error>

Returns private validators for a contract.

Trait Implementations

impl ChainNotify for Provider

fn new_blocks(&self, new_blocks: NewBlocks)

fires when chain has new blocks.

pub fn start(&self)

fires when chain achieves active mode

pub fn stop(&self)

fires when chain achieves passive mode

pub fn broadcast(&self, _message_type: ChainMessageType)

fires when chain broadcasts a message

pub fn block_pre_import(
    &self,
    _bytes: &Vec<u8, Global>,
    _hash: &H256,
    _difficulty: &U256
)

fires when new block is about to be imported implementations should be light

pub fn transactions_received(
    &self,
    _txs: &[UnverifiedTransaction],
    _peer_id: usize
)

fires when new transactions are received from a peer

impl IoHandler<ClientIoMessage<Client>> for Provider

fn initialize(&self, io: &IoContext<ClientIoMessage<Client>>)

Initialize the handler

fn timeout(&self, _io: &IoContext<ClientIoMessage<Client>>, timer: TimerToken)

Timer function called after a timeout created with HandlerIo::timeout.

pub fn message(&self, _io: &IoContext<Message>, _message: &Message)

Called when a broadcasted message is received. The message can only be sent from a different IO handler.