Restore IFA support on non-mainnet networks to match rgb-lib behaviour (#93)

Author: dcorral

src/error.rs

@@ -361,6 +361,9 @@ pub enum APIError {
     #[error("Layer 1 {0} is not supported")]
     UnsupportedLayer1(String),
 
+    #[error("Asset schema {0} is not supported on this network")]
+    UnsupportedSchema(String),
+
     #[error("Transport type is not supported")]
     UnsupportedTransportType,
 
@@ -479,6 +482,9 @@ impl From<RgbLibError> for APIError {
                 APIError::UnsupportedInflation(format!("{asset_schema}"))
             }
             RgbLibError::UnsupportedLayer1 { layer_1 } => APIError::UnsupportedLayer1(layer_1),
+            RgbLibError::UnsupportedSchema { asset_schema } => {
+                APIError::UnsupportedSchema(format!("{asset_schema}"))
+            }
             RgbLibError::UnsupportedTransportType => APIError::UnsupportedTransportType,
             _ => {
                 tracing::debug!("Unexpected rgb-lib error: {error:?}");
@@ -601,6 +607,7 @@ impl IntoResponse for APIError {
             | APIError::UnlockedNode
             | APIError::UnsupportedInflation(_)
             | APIError::UnsupportedLayer1(_)
+            | APIError::UnsupportedSchema(_)
             | APIError::UnsupportedTransportType
             | APIError::UnsupportedInExternalSignerMode(_) => {
                 (StatusCode::FORBIDDEN, self.to_string(), self.name())
@@ -700,3 +707,20 @@ impl IntoResponse for AuthError {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn unsupported_schema_maps_to_dedicated_error() {
+        let err = APIError::from(RgbLibError::UnsupportedSchema {
+            asset_schema: rgb_lib::AssetSchema::Ifa,
+        });
+        assert!(matches!(err, APIError::UnsupportedSchema(_)));
+        assert_eq!(
+            err.to_string(),
+            "Asset schema Ifa is not supported on this network"
+        );
+    }
+}

src/ldk.rs

@@ -1681,11 +1681,10 @@ async fn handle_ldk_events(
                     let channel_rgb_amount = rgb_info.local_rgb_amount;
                     let asset_id = rgb_info.contract_id.to_string();
                     let assignment = match rgb_info.schema {
-                        AssetSchema::Nia | AssetSchema::Cfa => {
+                        AssetSchema::Nia | AssetSchema::Cfa | AssetSchema::Ifa => {
                             Assignment::Fungible(channel_rgb_amount)
                         }
                         AssetSchema::Uda => Assignment::NonFungible,
-                        AssetSchema::Ifa => todo!(),
                     };
                     let recipient_id =
                         recipient_id_from_script_buf(script_buf, static_state.network);
@@ -3649,6 +3648,15 @@ pub(crate) fn select_chain_backend(
     }
 }
 
+// rgb-lib rejects wallets supporting IFA on mainnet
+fn supported_asset_schemas(bitcoin_network: BitcoinNetwork) -> Vec<AssetSchema> {
+    let mut schemas = vec![AssetSchema::Nia, AssetSchema::Cfa, AssetSchema::Uda];
+    if bitcoin_network != BitcoinNetwork::Mainnet {
+        schemas.push(AssetSchema::Ifa);
+    }
+    schemas
+}
+
 pub(crate) async fn start_ldk(
     app_state: Arc<AppState>,
     key_source: NodeKeySource,
@@ -4270,7 +4278,7 @@ pub(crate) async fn start_ldk(
                 bitcoin_network,
                 database_type: DatabaseType::Sqlite,
                 max_allocations_per_utxo: 1,
-                supported_schemas: vec![AssetSchema::Nia, AssetSchema::Cfa, AssetSchema::Uda],
+                supported_schemas: supported_asset_schemas(bitcoin_network),
                 reuse_addresses,
             },
             keys,
@@ -5520,4 +5528,22 @@ mod tests {
         assert_eq!(km.get_peer_storage_key().inner, b);
         assert_eq!(km.get_receive_auth_key().0, c);
     }
+
+    #[test]
+    fn ifa_supported_on_all_networks_but_mainnet() {
+        assert!(!supported_asset_schemas(BitcoinNetwork::Mainnet).contains(&AssetSchema::Ifa));
+        for network in [
+            BitcoinNetwork::Testnet,
+            BitcoinNetwork::Testnet4,
+            BitcoinNetwork::Signet,
+            BitcoinNetwork::SignetCustom,
+            BitcoinNetwork::Regtest,
+        ] {
+            let schemas = supported_asset_schemas(network);
+            assert!(schemas.contains(&AssetSchema::Ifa));
+            assert!(schemas.contains(&AssetSchema::Nia));
+            assert!(schemas.contains(&AssetSchema::Cfa));
+            assert!(schemas.contains(&AssetSchema::Uda));
+        }
+    }
 }

src/test/ifa_channel.rs

@@ -0,0 +1,133 @@
+use super::*;
+
+const TEST_DIR_BASE: &str = "tmp/ifa_channel/";
+
+#[serial_test::serial]
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+#[traced_test]
+async fn open_pay_close() {
+    initialize();
+
+    let test_dir_base = format!("{TEST_DIR_BASE}open_pay_close/");
+    let test_dir_node1 = format!("{test_dir_base}node1");
+    let test_dir_node2 = format!("{test_dir_base}node2");
+    let (node1_addr, _) = start_node(&test_dir_node1, NODE1_PEER_PORT, false).await;
+    let (node2_addr, _) = start_node(&test_dir_node2, NODE2_PEER_PORT, false).await;
+
+    fund_and_create_utxos(node1_addr, None).await;
+    fund_and_create_utxos(node2_addr, None).await;
+
+    let asset_id = issue_asset_ifa(node1_addr).await.asset_id;
+
+    let node2_pubkey = node_info(node2_addr).await.pubkey;
+    let channel = open_channel(
+        node1_addr,
+        &node2_pubkey,
+        Some(NODE2_PEER_PORT),
+        None,
+        Some(3500000),
+        Some(600),
+        Some(&asset_id),
+    )
+    .await;
+    assert_eq!(asset_balance_spendable(node1_addr, &asset_id).await, 400);
+
+    let asset_amount = Some(100);
+    let LNInvoiceResponse { invoice } =
+        ln_invoice(node2_addr, None, Some(&asset_id), asset_amount, 900).await;
+    send_payment(node1_addr, invoice.clone()).await;
+
+    let decoded = decode_ln_invoice(node1_addr, &invoice).await;
+    let payment = get_payment(node1_addr, &decoded.payment_hash, PaymentType::Outbound).await;
+    assert_eq!(payment.asset_id, Some(asset_id.clone()));
+    assert_eq!(payment.asset_amount, asset_amount);
+    assert_eq!(payment.status, HTLCStatus::Succeeded);
+    let payment = get_payment(
+        node2_addr,
+        &decoded.payment_hash,
+        PaymentType::InboundAutoClaim,
+    )
+    .await;
+    assert_eq!(payment.asset_id, Some(asset_id.clone()));
+    assert_eq!(payment.asset_amount, asset_amount);
+    assert_eq!(payment.status, HTLCStatus::Succeeded);
+
+    close_channel(node1_addr, &channel.channel_id, &node2_pubkey, false).await;
+    wait_for_balance(node1_addr, &asset_id, 900).await;
+    wait_for_balance(node2_addr, &asset_id, 100).await;
+}
+
+#[serial_test::serial]
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+#[traced_test]
+async fn virtual_open_pay_close() {
+    initialize();
+
+    let test_dir_base = format!("{TEST_DIR_BASE}virtual_open_pay_close/");
+    let host_peer_port = next_peer_port();
+    let client_peer_port = next_peer_port();
+
+    let (host_addr, _) = start_node_with_virtual_options(
+        &format!("{test_dir_base}host_node"),
+        host_peer_port,
+        false,
+        true,
+        vec![],
+    )
+    .await;
+    let host_pubkey = node_info(host_addr).await.pubkey;
+
+    fund_and_create_utxos(host_addr, None).await;
+    let asset_id = issue_asset_ifa(host_addr).await.asset_id;
+
+    let (client_addr, _) = start_node_with_virtual_options(
+        &format!("{test_dir_base}client_node"),
+        client_peer_port,
+        false,
+        true,
+        vec![bitcoin::secp256k1::PublicKey::from_str(&host_pubkey).unwrap()],
+    )
+    .await;
+    let client_pubkey = node_info(client_addr).await.pubkey;
+
+    let channel = open_virtual_channel(
+        host_addr,
+        &client_pubkey,
+        Some(client_peer_port),
+        Some(100_000),
+        Some(0),
+        Some(600),
+        Some(&asset_id),
+        None,
+    )
+    .await;
+    assert_eq!(channel.asset_id.as_deref(), Some(asset_id.as_str()));
+
+    let asset_amount = Some(100);
+    let LNInvoiceResponse { invoice } =
+        ln_invoice(client_addr, None, Some(&asset_id), asset_amount, 900).await;
+    let payment = send_payment(host_addr, invoice).await;
+    assert_eq!(payment.asset_id, Some(asset_id.clone()));
+    assert_eq!(payment.asset_amount, asset_amount);
+    assert_eq!(payment.status, HTLCStatus::Succeeded);
+    wait_for_ln_balance(host_addr, &asset_id, 500).await;
+    wait_for_ln_balance(client_addr, &asset_id, 100).await;
+
+    // virtual close requires the counterparty balance back at zero
+    let LNInvoiceResponse { invoice } = ln_invoice(
+        host_addr,
+        Some(3_000_000),
+        Some(&asset_id),
+        asset_amount,
+        900,
+    )
+    .await;
+    let payment = send_payment(client_addr, invoice).await;
+    assert_eq!(payment.status, HTLCStatus::Succeeded);
+    wait_for_ln_balance(host_addr, &asset_id, 600).await;
+    wait_for_ln_balance(client_addr, &asset_id, 0).await;
+
+    close_channel(host_addr, &channel.channel_id, &client_pubkey, false).await;
+
+    shutdown(&[host_addr, client_addr]).await;
+}

src/test/inflate.rs

@@ -5,7 +5,6 @@ const TEST_DIR_BASE: &str = "tmp/inflate/";
 #[serial_test::serial]
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 #[traced_test]
-#[ignore = "IFA removed from supported_schemas"]
 async fn success() {
     initialize();
 

src/test/issue.rs

@@ -26,21 +26,26 @@ async fn issue() {
 
     // issue assets
     let asset_cfa = issue_asset_cfa(node1_addr, Some(file_path)).await;
+    let asset_ifa = issue_asset_ifa(node1_addr).await;
     let asset_nia = issue_asset_nia(node1_addr).await;
     let asset_uda = issue_asset_uda(node1_addr, Some(file_path)).await;
 
     // check /listassets
     let assets = list_assets(node1_addr).await;
     let assets_cfa = assets.cfa.unwrap();
+    let assets_ifa = assets.ifa.unwrap();
     let assets_nia = assets.nia.unwrap();
     let assets_uda = assets.uda.unwrap();
     assert_eq!(assets_cfa.len(), 1);
+    assert_eq!(assets_ifa.len(), 1);
     assert_eq!(assets_nia.len(), 1);
     assert_eq!(assets_uda.len(), 1);
     let cfa_asset = assets_cfa.first().unwrap();
+    let ifa_asset = assets_ifa.first().unwrap();
     let nia_asset = assets_nia.first().unwrap();
     let uda_asset = assets_uda.first().unwrap();
     assert_eq!(cfa_asset.asset_id, asset_cfa.asset_id);
+    assert_eq!(ifa_asset.asset_id, asset_ifa.asset_id);
     assert_eq!(nia_asset.asset_id, asset_nia.asset_id);
     assert_eq!(uda_asset.asset_id, asset_uda.asset_id);
 

src/test/mod.rs

@@ -2935,6 +2935,7 @@ mod gossip_p2p;
 mod gossip_rgs;
 mod hodl_invoice;
 mod htlc_amount_checks;
+mod ifa_channel;
 mod inflate;
 mod init;
 mod init_electrum;