Merge pull request #256 from diba-io/HT/minor-improvements

Turn some unwraps into ? to better propagate errors instead of panics.

src/bitcoin/psbt.rs

@@ -27,10 +27,7 @@ pub async fn sign_psbt(
         blockchain.broadcast(&tx).await?;
 
         let txid = tx.txid();
-        let tx = blockchain
-            .get_tx(&txid)
-            .await
-            .expect("tx that was just broadcasted now exists");
+        let tx = blockchain.get_tx(&txid).await?;
 
         let mut sent = 0;
         let mut received = 0;

src/constants.rs

@@ -74,7 +74,7 @@ pub const NOSTR_PATH: &str = "m/44h/1237h/0h";
 
 // Magic number for versioning descriptors
 pub const DIBA_DESCRIPTOR_VERSION: u8 = 0;
-pub const DIBA_MAGIC_NO: [u8; 4] = [b'D', b'I', b'B', b'A'];
+pub const DIBA_MAGIC_NO: [u8; 4] = *b"DIBA";
 pub const DIBA_DESCRIPTOR: [u8; 5] = [
     DIBA_MAGIC_NO[0],
     DIBA_MAGIC_NO[1],

src/rgb.rs

@@ -426,10 +426,7 @@ pub async fn transfer_asset(sk: &str, request: RgbTransferRequest) -> Result<Rgb
     let psbt_hex = psbt.to_string();
     let consig = RgbTransferResponse {
         consig_id: transfer.bindle_id().to_string(),
-        consig: transfer
-            .to_strict_serialized::<U16>()
-            .expect("invalid transfer serialization")
-            .to_hex(),
+        consig: transfer.to_strict_serialized::<U16>()?.to_hex(),
         psbt: psbt_hex,
         commit: commit_hex,
     };
@@ -529,7 +526,7 @@ pub async fn list_contracts(sk: &str) -> Result<ContractsResponse> {
 
     let mut contracts = vec![];
 
-    for contract_id in stock.contract_ids().expect("invalid contracts state") {
+    for contract_id in stock.contract_ids()? {
         let resp = extract_contract_by_id(contract_id, &mut stock, &mut resolver, &mut wallet)?;
         contracts.push(resp);
     }
@@ -548,10 +545,10 @@ pub async fn list_interfaces(sk: &str) -> Result<InterfacesResponse> {
     let stock = retrieve_stock(sk, ASSETS_STOCK).await?;
 
     let mut interfaces = vec![];
-    for schema_id in stock.schema_ids().expect("invalid schemas state") {
-        let schema = stock.schema(schema_id).expect("invalid schemas state");
+    for schema_id in stock.schema_ids()? {
+        let schema = stock.schema(schema_id)?;
         for (iface_id, iimpl) in schema.clone().iimpls.into_iter() {
-            let face = stock.iface_by_id(iface_id).expect("invalid iface state");
+            let face = stock.iface_by_id(iface_id)?;
 
             let item = InterfaceDetail {
                 name: face.name.to_string(),
@@ -569,11 +566,11 @@ pub async fn list_schemas(sk: &str) -> Result<SchemasResponse> {
     let stock = retrieve_stock(sk, ASSETS_STOCK).await?;
 
     let mut schemas = vec![];
-    for schema_id in stock.schema_ids().expect("invalid schemas state") {
-        let schema = stock.schema(schema_id).expect("invalid schemas state");
+    for schema_id in stock.schema_ids()? {
+        let schema = stock.schema(schema_id)?;
         let mut ifaces = vec![];
         for (iface_id, _) in schema.clone().iimpls.into_iter() {
-            let face = stock.iface_by_id(iface_id).expect("invalid iface state");
+            let face = stock.iface_by_id(iface_id)?;
             ifaces.push(face.name.to_string());
         }
         schemas.push(SchemaDetail {

src/rgb/contract.rs

@@ -55,12 +55,9 @@ where
             .expect("invalid contract data")
             .to_base32(),
         bech32::Variant::Bech32m,
-    )
-    .expect("invalid contract data");
-    let contract_strict = contract_bindle
-        .to_strict_serialized::<0xFFFFFF>()
-        .expect("invalid contract data")
-        .to_hex();
+    )?;
+
+    let contract_strict = contract_bindle.to_strict_serialized::<0xFFFFFF>()?.to_hex();
 
     let contract_iface = stock
         .contract_iface(contract_bindle.contract_id(), iface_id.to_owned())
@@ -148,37 +145,24 @@ where
     for (index, (_, global_assign)) in contract_genesis.genesis.assignments.iter().enumerate() {
         let idx = index as u16;
         if global_assign.is_fungible() {
-            if let Some(reveal) = global_assign
-                .as_fungible_state_at(idx)
-                .expect("fail retrieve fungible data")
-            {
+            if let Some(reveal) = global_assign.as_fungible_state_at(idx)? {
                 supply += reveal.value.as_u64();
             }
         } else if global_assign.is_structured()
-            && global_assign
-                .as_structured_state_at(idx)
-                .expect("fail retrieve structured data")
-                .is_some()
+            && global_assign.as_structured_state_at(idx)?.is_some()
         {
             supply += 1;
         }
     }
 
     let genesis = contract_genesis.genesis.clone();
-    let genesis_strict = genesis
-        .to_strict_serialized::<0xFFFFFF>()
-        .expect("invalid genesis data")
-        .to_hex();
+    let genesis_strict = genesis.to_strict_serialized::<0xFFFFFF>()?.to_hex();
 
     let genesis_legacy = encode(
         "rgb",
-        genesis
-            .to_strict_serialized::<0xFFFFFF>()
-            .expect("invalid contract data")
-            .to_base32(),
+        genesis.to_strict_serialized::<0xFFFFFF>()?.to_base32(),
         bech32::Variant::Bech32m,
-    )
-    .expect("invalid contract data");
+    )?;
 
     let genesis_formats = GenesisFormats {
         legacy: genesis_legacy,
@@ -190,7 +174,10 @@ where
     let mut meta = none!();
     let ty: FieldName = FieldName::from("tokens");
     if contract_iface.global(ty.clone()).is_ok() {
-        let type_id = contract_iface.iface.global_type(&ty).expect("");
+        let type_id = contract_iface
+            .iface
+            .global_type(&ty)
+            .expect("no global type id");
 
         let type_schema = contract_iface
             .state
@@ -217,16 +204,12 @@ where
             if let Some(preview) = token_data.preview {
                 media = MediaInfo {
                     ty: preview.ty.to_string(),
-                    source: String::from_utf8(preview.data.to_inner()).expect("invalid data"),
+                    source: String::from_utf8(preview.data.to_inner())?,
                 };
             }
 
             let single = ContractMetadata::UDA(UDADetail {
-                token_index: token_data
-                    .index
-                    .to_string()
-                    .parse()
-                    .expect("invalid token_index"),
+                token_index: token_data.index.to_string().parse()?,
                 ticker: ticker.clone(),
                 name: name.clone(),
                 description: description.clone(),

src/rgb/issue.rs

@@ -50,16 +50,12 @@ where
     T: ResolveHeight + ResolveTx,
     T::Error: 'static,
 {
-    let iface_name = match TypeName::from_str(iface) {
-        Ok(name) => name,
-        _ => return Err(IssueError::Forge(BuilderError::InterfaceMismatch)),
-    };
+    let iface_name = TypeName::from_str(iface)
+        .map_err(|_| IssueError::Forge(BuilderError::InterfaceMismatch))?;
 
-    let binding = stock.to_owned();
-    let iface = match binding.iface_by_name(&iface_name) {
-        Ok(name) => name,
-        _ => return Err(IssueError::Forge(BuilderError::InterfaceMismatch)),
-    };
+    let iface = stock
+        .iface_by_name(&iface_name)
+        .map_err(|_| IssueError::Forge(BuilderError::InterfaceMismatch))?;
 
     if ticker.len() < 3 || ticker.len() > 8 || ticker.chars().any(|c| c < 'A' && c > 'Z') {
         return Err(IssueError::InvalidTicker("Ticker must be between 3 and 8 chars, contain no spaces and consist only of capital letters".to_string()));
@@ -82,21 +78,16 @@ where
         _ => return Err(IssueError::ContractNotfound(iface.name.to_string())),
     };
 
-    let resp = match contract_issued {
-        Ok(resp) => resp,
-        Err(err) => return Err(IssueError::Forge(err)),
-    };
+    let resp = contract_issued.map_err(IssueError::Forge)?;
+    let contract_id = resp.contract_id().to_string();
 
-    let resp = match resp.clone().validate(resolver) {
-        Ok(resp) => resp,
-        Err(_err) => return Err(IssueError::ContractInvalid(resp.contract_id().to_string())),
-    };
+    let resp = resp
+        .validate(resolver)
+        .map_err(|_| IssueError::ContractInvalid(contract_id.clone()))?;
 
     stock
         .import_contract(resp.clone(), resolver)
-        .or(Err(IssueError::ImportContract(
-            resp.contract_id().to_string(),
-        )))?;
+        .or(Err(IssueError::ImportContract(contract_id)))?;
 
     Ok(resp)
 }