chain/ethereum: Avoid a clone for EthereumEventData in ABI conversion

Author: lutter

chain/ethereum/src/runtime/abi.rs

@@ -49,6 +49,18 @@ impl ToAscObj<AscLogParamArray> for Vec<ethabi::LogParam> {
     }
 }
 
+impl ToAscObj<AscLogParamArray> for &[ethabi::LogParam] {
+    fn to_asc_obj<H: AscHeap + ?Sized>(
+        &self,
+        heap: &mut H,
+        gas: &GasCounter,
+    ) -> Result<AscLogParamArray, HostExportError> {
+        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
+        let content = content?;
+        Ok(AscLogParamArray(Array::new(&content, heap, gas)?))
+    }
+}
+
 impl AscIndexId for AscLogParamArray {
     const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::ArrayEventParam;
 }
@@ -567,17 +579,17 @@ where
         gas: &GasCounter,
     ) -> Result<AscEthereumEvent<T, B>, HostExportError> {
         Ok(AscEthereumEvent {
-            address: asc_new(heap, &self.address, gas)?,
-            log_index: asc_new(heap, &BigInt::from_unsigned_u256(&self.log_index), gas)?,
+            address: asc_new(heap, self.address(), gas)?,
+            log_index: asc_new(heap, &BigInt::from_unsigned_u256(self.log_index()), gas)?,
             transaction_log_index: asc_new(
                 heap,
-                &BigInt::from_unsigned_u256(&self.transaction_log_index),
+                &BigInt::from_unsigned_u256(self.transaction_log_index()),
                 gas,
             )?,
             log_type: self
-                .log_type
-                .clone()
-                .map(|log_type| asc_new(heap, &log_type, gas))
+                .log_type()
+                .as_ref()
+                .map(|log_type| asc_new(heap, log_type, gas))
                 .unwrap_or(Ok(AscPtr::null()))?,
             block: asc_new::<B, EthereumBlockData, _>(heap, &self.block, gas)?,
             transaction: asc_new::<T, EthereumTransactionData, _>(heap, &self.transaction, gas)?,

chain/ethereum/src/trigger.rs

@@ -146,15 +146,12 @@ impl ToAscPtr for MappingTrigger {
                 calls: _,
             } => {
                 let api_version = heap.api_version();
-                let ethereum_event_data = EthereumEventData {
-                    block: EthereumBlockData::from(block.as_ref()),
-                    transaction: EthereumTransactionData::new(transaction.deref()),
-                    address: log.address,
-                    log_index: log.log_index.unwrap_or(U256::zero()),
-                    transaction_log_index: log.log_index.unwrap_or(U256::zero()),
-                    log_type: log.log_type.clone(),
-                    params,
-                };
+                let ethereum_event_data = EthereumEventData::new(
+                    block.as_ref(),
+                    transaction.as_ref(),
+                    log.as_ref(),
+                    &params,
+                );
                 if api_version >= API_VERSION_0_0_7 {
                     asc_new::<
                         AscEthereumEvent_0_0_7<
@@ -553,13 +550,45 @@ impl<'a> EthereumTransactionData<'a> {
 /// An Ethereum event logged from a specific contract address and block.
 #[derive(Debug, Clone)]
 pub struct EthereumEventData<'a> {
-    pub address: Address,
-    pub log_index: U256,
-    pub transaction_log_index: U256,
-    pub log_type: Option<String>,
     pub block: EthereumBlockData<'a>,
     pub transaction: EthereumTransactionData<'a>,
-    pub params: Vec<LogParam>,
+    pub params: &'a [LogParam],
+    log: &'a Log,
+}
+
+impl<'a> EthereumEventData<'a> {
+    pub fn new(
+        block: &'a Block<Transaction>,
+        tx: &'a Transaction,
+        log: &'a Log,
+        params: &'a [LogParam],
+    ) -> Self {
+        EthereumEventData {
+            block: EthereumBlockData::from(block),
+            transaction: EthereumTransactionData::new(tx),
+            log,
+            params,
+        }
+    }
+
+    pub fn address(&self) -> &Address {
+        &self.log.address
+    }
+
+    pub fn log_index(&self) -> &U256 {
+        self.log.log_index.as_ref().unwrap_or(&U256_DEFAULT)
+    }
+
+    pub fn transaction_log_index(&self) -> &U256 {
+        self.log
+            .transaction_log_index
+            .as_ref()
+            .unwrap_or(&U256_DEFAULT)
+    }
+
+    pub fn log_type(&self) -> &Option<String> {
+        &self.log.log_type
+    }
 }
 
 /// An Ethereum call executed within a transaction within a block to a contract address.