Address review comments

Author: azarovh

api-server/scanner-lib/src/blockchain_state/mod.rs

@@ -1201,7 +1201,7 @@ async fn update_tables_from_transaction_inputs<T: ApiServerStorageWrite>(
                             )
                             .await;
                         }
-                        TxOutput::Htlc(_, _) => {} // TODO: support htlc
+                        TxOutput::Htlc(_, _) => {} // TODO(HTLC)
                         TxOutput::LockThenTransfer(output_value, destination, _)
                         | TxOutput::Transfer(output_value, destination) => {
                             let address = Address::<Destination>::new(&chain_config, destination)
@@ -1616,7 +1616,7 @@ async fn update_tables_from_transaction_outputs<T: ApiServerStorageWrite>(
                         .expect("Unable to set locked utxo");
                 }
             }
-            TxOutput::Htlc(_, _) => {} // TODO: support htlc
+            TxOutput::Htlc(_, _) => {} // TODO(HTLC)
         }
     }
 
@@ -1816,6 +1816,6 @@ fn get_tx_output_destination(txo: &TxOutput) -> Option<&Destination> {
         | TxOutput::Burn(_)
         | TxOutput::DelegateStaking(_, _)
         | TxOutput::DataDeposit(_) => None,
-        TxOutput::Htlc(_, _) => None, // TODO: support htlc
+        TxOutput::Htlc(_, _) => None, // TODO(HTLC)
     }
 }

common/src/chain/config/builder.rs

@@ -50,9 +50,9 @@ const TESTNET_TOKEN_FORK_HEIGHT: BlockHeight = BlockHeight::new(78440);
 // The fork, at which we upgrade chainstate to distribute reward to staker proportionally to their balance
 // and change various tokens fees
 const TESTNET_STAKER_REWARD_AND_TOKENS_FEE_FORK_HEIGHT: BlockHeight = BlockHeight::new(138244);
-// The fork, at which txs with htlc outputs become valid
-const TESTNET_HTLC_FORK_HEIGHT: BlockHeight = BlockHeight::new(99999999);
-const MAINNET_HTLC_FORK_HEIGHT: BlockHeight = BlockHeight::new(99999999);
+// The fork, at which txs with htlc and orders outputs become valid
+const TESTNET_HTLC_AND_ORDERS_FORK_HEIGHT: BlockHeight = BlockHeight::new(99999999);
+const MAINNET_HTLC_AND_ORDERS_FORK_HEIGHT: BlockHeight = BlockHeight::new(99999999);
 
 impl ChainType {
     fn default_genesis_init(&self) -> GenesisBlockInit {
@@ -170,7 +170,7 @@ impl ChainType {
                         ),
                     ),
                     (
-                        MAINNET_HTLC_FORK_HEIGHT,
+                        MAINNET_HTLC_AND_ORDERS_FORK_HEIGHT,
                         ChainstateUpgrade::new(
                             TokenIssuanceVersion::V1,
                             RewardDistributionVersion::V1,
@@ -223,7 +223,7 @@ impl ChainType {
                         ),
                     ),
                     (
-                        TESTNET_HTLC_FORK_HEIGHT,
+                        TESTNET_HTLC_AND_ORDERS_FORK_HEIGHT,
                         ChainstateUpgrade::new(
                             TokenIssuanceVersion::V1,
                             RewardDistributionVersion::V1,

common/src/chain/transaction/output/htlc.rs

@@ -21,6 +21,15 @@ use serialization::{Decode, Encode};
 
 use super::{timelock::OutputTimeLock, Destination};
 
+fixed_hash::construct_fixed_hash! {
+    #[derive(Encode, Decode, serde::Serialize, serde::Deserialize)]
+    pub struct SecretHash(20);
+}
+
+impl rpc_description::HasValueHint for SecretHash {
+    const HINT_SER: rpc_description::ValueHint = rpc_description::ValueHint::HEX_STRING;
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Encode, Decode, serde::Serialize, serde::Deserialize)]
 pub struct HashedTimelockContract {
     // can be spent either by a specific address that knows the secret
@@ -108,19 +117,24 @@ mod tests {
     }
 
     #[rstest]
-    #[case("\"0000000000000000000000000000000000000000\"")]
-    #[case("\"0000000000000000000000000000000000000001\"")]
-    #[case("\"ac7b960a8d03705d1ace08b1a19da3fdcc99ddbd\"")]
-    #[case("\"e4732fe6f1ed1cddc2ed4b328fff5224276e3f6f\"")]
-    #[case("\"0103b9683e51e5aba83b8a34c9b98ce67d66136c\"")]
-    fn deserialize_valid(#[case] s: String) {
-        serde_json::from_str::<HtlcSecretHash>(&s).unwrap();
+    #[case("\"0000000000000000000000000000000000000000\"", [0;20])]
+    #[case("\"0000000000000000000000000000000000000001\"", [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1])]
+    #[case("\"ac7b960a8d03705d1ace08b1a19da3fdcc99ddbd\"", [0xac,0x7b,0x96,0x0a,0x8d,0x03,0x70,0x5d,0x1a,0xce,0x08,0xb1,0xa1,0x9d,0xa3,0xfd,0xcc,0x99,0xdd,0xbd])]
+    #[case("\"e4732fe6f1ed1cddc2ed4b328fff5224276e3f6f\"", [0xe4,0x73,0x2f,0xe6,0xf1,0xed,0x1c,0xdd,0xc2,0xed,0x4b,0x32,0x8f,0xff,0x52,0x24,0x27,0x6e,0x3f,0x6f])]
+    #[case("\"0103b9683e51e5aba83b8a34c9b98ce67d66136c\"", [0x01,0x03,0xb9,0x68,0x3e,0x51,0xe5,0xab,0xa8,0x3b,0x8a,0x34,0xc9,0xb9,0x8c,0xe6,0x7d,0x66,0x13,0x6c])]
+    fn deserialize_valid(#[case] str: String, #[case] expected: [u8; 20]) {
+        let result = serde_json::from_str::<HtlcSecretHash>(&str).unwrap();
+        assert_eq!(result, HtlcSecretHash::from_slice(&expected));
     }
 
     #[rstest]
-    #[case("\"00000000000000000000000000000000000000000000000000000000000000\"")]
-    #[case("\"000000000000000000000000000000000invalid\"")]
-    fn deserialize_invalid(#[case] s: String) {
-        serde_json::from_str::<HtlcSecretHash>(&s).unwrap_err();
+    #[case(
+        "\"00000000000000000000000000000000000000000000000000000000000000\"",
+        "Invalid input length"
+    )]
+    #[case("\"000000000000000000000000000000000invalid\"", "Invalid character")]
+    fn deserialize_invalid(#[case] s: String, #[case] expected_msg: String) {
+        let err = serde_json::from_str::<HtlcSecretHash>(&s).unwrap_err();
+        assert!(err.to_string().contains(&expected_msg));
     }
 }

common/src/chain/transaction/output/mod.rs

@@ -42,15 +42,6 @@ pub mod output_value;
 pub mod stakelock;
 pub mod timelock;
 
-fixed_hash::construct_fixed_hash! {
-    #[derive(Encode, Decode, serde::Serialize, serde::Deserialize)]
-    pub struct SecretHash(20);
-}
-
-impl rpc_description::HasValueHint for SecretHash {
-    const HINT_SER: rpc_description::ValueHint = rpc_description::ValueHint::HEX_STRING;
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Encode, Decode, VariantCount)]
 pub enum Destination {
     #[codec(index = 0)]

mintscript/src/translate.rs

@@ -258,7 +258,9 @@ impl<C: InputInfoProvider> TranslateInput<C> for TimelockOnly {
                     Ok(WitnessScript::timelock(*timelock))
                 }
                 TxOutput::Htlc(_, htlc) => match ctx.witness() {
-                    InputWitness::NoSignature(_) => Ok(WitnessScript::TRUE),
+                    InputWitness::NoSignature(_) => Err(TranslationError::SignatureError(
+                        DestinationSigError::SignatureNotFound,
+                    )),
                     InputWitness::Standard(sig) => {
                         let htlc_spend =
                             AuthorizedHashedTimelockContractSpend::from_data(sig.raw_signature())?;

wallet/src/account/transaction_list/mod.rs

@@ -113,7 +113,7 @@ fn own_output(key_chain: &AccountKeyChainImpl, output: &TxOutput) -> bool {
         TxOutput::Transfer(_, dest) | TxOutput::LockThenTransfer(_, dest, _) => KeyPurpose::ALL
             .iter()
             .any(|purpose| key_chain.get_leaf_key_chain(*purpose).is_destination_mine(dest)),
-        TxOutput::Htlc(_, _) => false, // TODO: support htlc
+        TxOutput::Htlc(_, _) => false, // TODO(HTLC)
         TxOutput::Burn(_)
         | TxOutput::CreateStakePool(_, _)
         | TxOutput::ProduceBlockFromStake(_, _)

wallet/src/send_request/mod.rs

@@ -307,7 +307,7 @@ where
         | TxOutput::Burn(_)
         | TxOutput::DelegateStaking(_, _)
         | TxOutput::DataDeposit(_) => None,
-        TxOutput::Htlc(_, _) => None, // TODO: support htlc
+        TxOutput::Htlc(_, _) => None, // TODO(HTLC)
     }
 }
 

wallet/types/src/utxo_types.rs

@@ -53,7 +53,7 @@ pub fn get_utxo_type(output: &TxOutput) -> Option<UtxoType> {
         | TxOutput::DelegateStaking(_, _)
         | TxOutput::IssueFungibleToken(_)
         | TxOutput::DataDeposit(_) => None,
-        TxOutput::Htlc(_, _) => None, // TODO: support htlc
+        TxOutput::Htlc(_, _) => None, // TODO(HTLC)
     }
 }
 pub fn get_utxo_state(output: &TxState) -> UtxoState {