Method process_transaction

chain/src/blockchain.rs:208–265

TODO(ddimaria): handle TransactionKind::ContractExecution

(
        &mut self,
        transaction: &'a mut Transaction,
    )

    // TODO(ddimaria): handle TransactionKind::ContractExecution
    pub(crate) fn process_transaction<'a>(
        &mut self,
        transaction: &'a mut Transaction,
    ) -> Result<(&'a mut Transaction, TransactionReceipt)> {
        let mut contract_address: Option<Account> = None;
        let transaction_hash = transaction.transaction_hash()?;

        // ignore transactions without a nonce
        if let Some(nonce) = transaction.nonce {
            tracing::info!("Processing Transaction {:?}", transaction_hash);

            // create the `to` account if it doesn't exist
            if let Some(to) = transaction.to {
                self.accounts.add_empty_account(&to)?;
            }

            // TODO(ddimaria): remove this copy
            let kind = transaction.to_owned().kind()?;

            match kind {
                TransactionKind::Regular(from, to, value) => {
                    self.accounts.transfer(&from, &to, value)
                }
                TransactionKind::ContractDeployment(from, data) => {
                    contract_address = self.accounts.add_contract_account(&from, data).ok();
                    Ok(())
                }
                TransactionKind::ContractExecution(_from, to, data) => {
                    let code = self
                        .accounts
                        .get_account(&to)?
                        .code_hash
                        .ok_or_else(|| ChainError::NotAContractAccount(to.to_string()))?;
                    let (function, params): (&str, Vec<&str>) = bincode::deserialize(&data)?;

                    // call the function in the contract
                    runtime::contract::call_function(&code, function, &params)
                        .map_err(|e| ChainError::RuntimeError(to.to_string(), e.to_string()))
                }
            }?;

            // update the nonce
            self.accounts.update_nonce(&transaction.from, nonce)?;

            let transaction_receipt = TransactionReceipt {
                block_hash: None,
                block_number: None,
                contract_address,
                transaction_hash,
            };

            return Ok((transaction, transaction_receipt));
        }

        Err(ChainError::MissingTransactionNonce(
            transaction_hash.to_string(),
        ))
    }