update inx and sdk

Cargo.toml

@@ -74,12 +74,12 @@ inx = { git = "https://github.com/iotaledger/inx", default-features = false, opt
 tonic = { version = "0.10", default-features = false, optional = true }
 
 [dev-dependencies]
-bincode = { version = "1.3", default-features = false }
+# bincode = { version = "1.3", default-features = false }
 iota-sdk = { git = "https://github.com/iotaledger/iota-sdk", branch = "2.0", default-features = false, features = [ "std", "serde", "rand" ] }
 pretty_assertions = { version = "1.4", default-features = false, features = [ "std" ] }
 rand = { version = "0.8", default-features = false, features = [ "std" ] }
-ron = { version = "0.8", default-features = false }
-yazi = { version = "0.1", default-features = false }
+# ron = { version = "0.8", default-features = false }
+# yazi = { version = "0.2", default-features = false }
 
 [features]
 default = [

src/analytics/tangle/block_activity.rs

@@ -45,7 +45,7 @@ impl Analytics for BlockActivityMeasurement {
             Some(Payload::CandidacyAnnouncement(_)) => self.candidacy_announcement_count += 1,
             None => self.no_payload_count += 1,
         }
-        match metadata.block_state {
+        match &metadata.block_state {
             BlockState::Pending => self.block_pending_count += 1,
             BlockState::Accepted => self.block_accepted_count += 1,
             BlockState::Confirmed => self.block_confirmed_count += 1,
@@ -54,7 +54,7 @@ impl Analytics for BlockActivityMeasurement {
             BlockState::Failed => self.block_failed_count += 1,
             BlockState::Unknown => self.block_unknown_count += 1,
         }
-        if let Some(txn_state) = &metadata.transaction_state {
+        if let Some(txn_state) = metadata.transaction_metadata.as_ref().map(|m| &m.transaction_state) {
             match txn_state {
                 TransactionState::Pending => self.txn_pending_count += 1,
                 TransactionState::Accepted => self.txn_accepted_count += 1,

src/bin/inx-chronicle/api/core/routes.rs

@@ -21,10 +21,12 @@ use chronicle::{
 use iota_sdk::types::{
     api::core::{
         BaseTokenResponse, BlockMetadataResponse, OutputWithMetadataResponse, ProtocolParametersResponse,
-        UtxoChangesResponse,
+        TransactionMetadataResponse, UtxoChangesResponse,
     },
     block::{
-        output::{OutputId, OutputMetadata as OutputMetadataResponse},
+        output::{
+            OutputConsumptionMetadata, OutputId, OutputInclusionMetadata, OutputMetadata as OutputMetadataResponse,
+        },
         payload::signed_transaction::TransactionId,
         slot::{SlotCommitment, SlotCommitmentId, SlotIndex},
         BlockDto, BlockId,
@@ -157,9 +159,14 @@ fn create_block_metadata_response(block_id: BlockId, metadata: BlockMetadata) ->
     BlockMetadataResponse {
         block_id,
         block_state: metadata.block_state.into(),
-        transaction_state: metadata.transaction_state.map(Into::into),
         block_failure_reason: metadata.block_failure_reason.map(Into::into),
-        transaction_failure_reason: metadata.transaction_failure_reason.map(Into::into),
+        transaction_metadata: metadata
+            .transaction_metadata
+            .map(|metadata| TransactionMetadataResponse {
+                transaction_id: metadata.transaction_id,
+                transaction_state: metadata.transaction_state.into(),
+                transaction_failure_reason: metadata.transaction_failure_reason.map(Into::into),
+            }),
     }
 }
 
@@ -183,12 +190,20 @@ fn create_output_metadata_response(
     latest_commitment_id: SlotCommitmentId,
 ) -> ApiResult<OutputMetadataResponse> {
     Ok(OutputMetadataResponse::new(
-        metadata.block_id,
         output_id,
-        metadata.spent_metadata.is_some(),
-        metadata.spent_metadata.as_ref().map(|m| m.commitment_id_spent),
-        metadata.spent_metadata.as_ref().map(|m| m.transaction_id_spent),
-        Some(metadata.commitment_id_included),
+        metadata.block_id,
+        OutputInclusionMetadata::new(
+            metadata.commitment_id_included.slot_index(),
+            *output_id.transaction_id(),
+            Some(metadata.commitment_id_included),
+        ),
+        metadata.spent_metadata.map(|metadata| {
+            OutputConsumptionMetadata::new(
+                metadata.slot_spent,
+                metadata.transaction_id_spent,
+                Some(metadata.commitment_id_spent),
+            )
+        }),
         latest_commitment_id,
     ))
 }
@@ -220,10 +235,7 @@ async fn output(
 
     let metadata = create_output_metadata_response(output_id, metadata, latest_slot.commitment_id)?;
 
-    Ok(IotaRawResponse::Json(OutputWithMetadataResponse {
-        metadata,
-        output: (&output).into(),
-    }))
+    Ok(IotaRawResponse::Json(OutputWithMetadataResponse { metadata, output }))
 }
 
 async fn output_metadata(

src/inx/ledger.rs

@@ -197,17 +197,17 @@ impl ConvertFrom<proto::block_metadata::BlockState> for BlockState {
     }
 }
 
-impl ConvertFrom<proto::block_metadata::TransactionState> for Option<TransactionState> {
-    fn convert_from(proto: proto::block_metadata::TransactionState) -> Self {
-        use proto::block_metadata::TransactionState as ProtoState;
-        Some(match proto {
-            ProtoState::NoTransaction => return None,
+impl ConvertFrom<proto::transaction_metadata::TransactionState> for TransactionState {
+    fn convert_from(proto: proto::transaction_metadata::TransactionState) -> Self {
+        use proto::transaction_metadata::TransactionState as ProtoState;
+        match proto {
             ProtoState::Pending => TransactionState::Pending,
             ProtoState::Confirmed => TransactionState::Confirmed,
             ProtoState::Finalized => TransactionState::Finalized,
             ProtoState::Failed => TransactionState::Failed,
             ProtoState::Accepted => TransactionState::Accepted,
-        })
+            ProtoState::NoTransaction => panic!("tried to convert a transaction state where no transaction exists"),
+        }
     }
 }
 
@@ -233,9 +233,9 @@ impl ConvertFrom<proto::block_metadata::BlockFailureReason> for Option<BlockFail
     }
 }
 
-impl ConvertFrom<proto::block_metadata::TransactionFailureReason> for Option<TransactionFailureReason> {
-    fn convert_from(proto: proto::block_metadata::TransactionFailureReason) -> Self {
-        use proto::block_metadata::TransactionFailureReason as ProtoState;
+impl ConvertFrom<proto::transaction_metadata::TransactionFailureReason> for Option<TransactionFailureReason> {
+    fn convert_from(proto: proto::transaction_metadata::TransactionFailureReason) -> Self {
+        use proto::transaction_metadata::TransactionFailureReason as ProtoState;
         Some(match proto {
             ProtoState::None => return None,
             ProtoState::UtxoInputAlreadySpent => TransactionFailureReason::InputUtxoAlreadySpent,

src/inx/responses.rs

@@ -14,7 +14,7 @@ use super::{
 use crate::{
     maybe_missing,
     model::{
-        block_metadata::{BlockMetadata, BlockWithMetadata},
+        block_metadata::{BlockMetadata, BlockWithMetadata, TransactionMetadata},
         ledger::{LedgerOutput, LedgerSpent},
         node::{BaseToken, NodeConfiguration, NodeStatus},
         protocol::ProtocolParameters,
@@ -192,14 +192,28 @@ impl TryConvertFrom<proto::BlockMetadata> for BlockMetadata {
     {
         Ok(Self {
             block_state: proto.block_state().convert(),
-            transaction_state: proto.transaction_state().convert(),
             block_failure_reason: proto.block_failure_reason().convert(),
-            transaction_failure_reason: proto.transaction_failure_reason().convert(),
+            transaction_metadata: proto.transaction_metadata.map(TryConvertTo::try_convert).transpose()?,
             block_id: maybe_missing!(proto.block_id).try_convert()?,
         })
     }
 }
 
+impl TryConvertFrom<proto::TransactionMetadata> for TransactionMetadata {
+    type Error = InxError;
+
+    fn try_convert_from(proto: proto::TransactionMetadata) -> Result<Self, Self::Error>
+    where
+        Self: Sized,
+    {
+        Ok(Self {
+            transaction_state: proto.transaction_state().convert(),
+            transaction_failure_reason: proto.transaction_failure_reason().convert(),
+            transaction_id: maybe_missing!(proto.transaction_id).try_convert()?,
+        })
+    }
+}
+
 impl TryConvertFrom<proto::BlockWithMetadata> for BlockWithMetadata {
     type Error = InxError;