feat: add wip, configurables - pending rust sdk bug resolution

Author: DefiCake

packages/fungible-token/bridge-fungible-token/src/main.sw

@@ -260,7 +260,7 @@ impl Bridge for Contract {
     }
 
     fn bridged_token_decimals() -> u8 {
-        BRIDGED_TOKEN_DECIMALS
+        DECIMALS
     }
 
     fn bridged_token_gateway() -> b256 {

packages/fungible-token/bridge-fungible-token/src/utils.sw

@@ -3,6 +3,7 @@ library;
 use ::cast::*;
 use ::data_structures::MessageData;
 use ::errors::BridgeFungibleTokenError;
+use ::events::DepositEvent;
 use std::{
     bytes::Bytes,
     constants::ZERO_B256,
@@ -55,6 +56,9 @@ pub fn adjust_deposit_decimals(
     decimals: u8,
     bridged_token_decimals: u8,
 ) -> Result<u64, BridgeFungibleTokenError> {
+    log(decimals);
+    log(decimals);
+    log(decimals);
     let value = val.as_u256();
 
     let adjusted: u256 = if bridged_token_decimals > decimals {

packages/fungible-token/bridge-fungible-token/tests/functions/message_receiver/mod.rs

@@ -13,15 +13,17 @@ use std::str::FromStr;
 mod success {
     use super::*;
 
-    use crate::utils::interface::src20::total_supply;
-    use crate::utils::setup::get_asset_id;
+    use crate::utils::constants::BRIDGED_TOKEN_GATEWAY;
+    use crate::utils::interface::src20::{decimals, total_supply};
+    use crate::utils::setup::{decode_hex, get_asset_id};
     use crate::utils::{
         constants::MESSAGE_AMOUNT,
         setup::{
             contract_balance, create_recipient_contract, encode_hex, precalculate_deposit_id,
             wallet_balance, RefundRegisteredEvent,
         },
     };
+    use fuels::types::SizedAsciiString;
     use fuels::{prelude::AssetId, programs::contract::SettableContract, types::Bits256};
     use primitive_types::U256 as Unsigned256;
 
@@ -74,6 +76,232 @@ mod success {
         assert_eq!(balance, config.fuel_equivalent_amount(config.amount.test));
     }
 
+    // This test is akin to bridging WBTC and mimicking its decimals on Fuel
+    #[tokio::test]
+    async fn deposit_to_wallet_with_6_decimals() {
+        let mut wallet: fuels::accounts::wallet::WalletUnlocked = create_wallet();
+        let proxy_token_decimals = 6u8;
+        let bridged_token_decimals = 6u8;
+        let config = BridgingConfig::new(bridged_token_decimals, proxy_token_decimals);
+
+        let configurables: Option<BridgeFungibleTokenContractConfigurables> = Some(
+            BridgeFungibleTokenContractConfigurables::new()
+                .with_DECIMALS(proxy_token_decimals)
+                .with_BRIDGED_TOKEN_DECIMALS(bridged_token_decimals)
+        );
+
+        let (message, coin, deposit_contract) = create_msg_data(
+            BRIDGED_TOKEN,
+            BRIDGED_TOKEN_ID,
+            FROM,
+            *wallet.address().hash(),
+            config.amount.test,
+            configurables.clone(),
+            false,
+            None,
+        )
+        .await;
+
+        assert_eq!(config.amount.test.as_u64(), config.fuel_equivalent_amount(config.amount.test));
+        dbg!(config.amount.test.as_u64());
+        dbg!(config.fuel_equivalent_amount(config.amount.test));
+        
+        let (bridge, utxo_inputs) = setup_environment(
+            &mut wallet,
+            vec![coin],
+            vec![message],
+            deposit_contract,
+            None,
+            configurables,
+        )
+        .await;
+
+        let provider = wallet.provider().expect("Needs provider");
+
+        // Relay the test message to the bridge contract
+        let tx = relay_message_to_contract(
+            &wallet,
+            utxo_inputs.message[0].clone(),
+            utxo_inputs.contract,
+        )
+        .await;
+
+        let receipts = provider.tx_status(&tx).await.unwrap().take_receipts();
+
+        let refund_registered_events = bridge
+            .log_decoder()
+            .decode_logs_with_type::<RefundRegisteredEvent>(&receipts)
+            .unwrap();
+
+        assert_eq!(refund_registered_events.len(), 0);
+
+        let asset_balance =
+            contract_balance(provider, bridge.contract_id(), AssetId::default()).await;
+        let balance = wallet_balance(&wallet, &get_asset_id(bridge.contract_id())).await;
+
+        // Verify the message value was received by the bridge
+        assert_eq!(asset_balance, MESSAGE_AMOUNT);
+
+        // Check that wallet now has bridged coins
+        assert_eq!(balance, config.fuel_equivalent_amount(config.amount.test));
+    }
+
+    // This test is akin to bridging USDC or USDT and mimicking its decimals on Fuel
+    #[tokio::test]
+    async fn deposit_to_wallet_with_8_decimals() {
+        let mut wallet: fuels::accounts::wallet::WalletUnlocked = create_wallet();
+        let proxy_token_decimals = 8u8;
+        let bridged_token_decimals = 8u8;
+        let config = BridgingConfig::new(bridged_token_decimals, proxy_token_decimals);
+
+        let configurables: Option<BridgeFungibleTokenContractConfigurables> = Some(
+            BridgeFungibleTokenContractConfigurables::new()
+                .with_DECIMALS(proxy_token_decimals)
+                .with_BRIDGED_TOKEN_DECIMALS(bridged_token_decimals)
+        );
+
+        let (message, coin, deposit_contract) = create_msg_data(
+            BRIDGED_TOKEN,
+            BRIDGED_TOKEN_ID,
+            FROM,
+            *wallet.address().hash(),
+            config.amount.test,
+            configurables.clone(),
+            false,
+            None,
+        )
+        .await;
+
+        assert_eq!(config.amount.test.as_u64(), config.fuel_equivalent_amount(config.amount.test));
+        dbg!(config.amount.test.as_u64());
+        dbg!(config.fuel_equivalent_amount(config.amount.test));
+        
+        let (bridge, utxo_inputs) = setup_environment(
+            &mut wallet,
+            vec![coin],
+            vec![message],
+            deposit_contract,
+            None,
+            configurables,
+        )
+        .await;
+
+        let provider = wallet.provider().expect("Needs provider");
+
+        // Relay the test message to the bridge contract
+        let tx = relay_message_to_contract(
+            &wallet,
+            utxo_inputs.message[0].clone(),
+            utxo_inputs.contract,
+        )
+        .await;
+
+        let receipts = provider.tx_status(&tx).await.unwrap().take_receipts();
+
+        let refund_registered_events = bridge
+            .log_decoder()
+            .decode_logs_with_type::<RefundRegisteredEvent>(&receipts)
+            .unwrap();
+
+        assert_eq!(refund_registered_events.len(), 0);
+
+        let asset_balance =
+            contract_balance(provider, bridge.contract_id(), AssetId::default()).await;
+        let balance = wallet_balance(&wallet, &get_asset_id(bridge.contract_id())).await;
+
+        // Verify the message value was received by the bridge
+        assert_eq!(asset_balance, MESSAGE_AMOUNT);
+
+        // Check that wallet now has bridged coins
+        assert_eq!(balance, config.fuel_equivalent_amount(config.amount.test));
+    }
+
+    // This test is akin to bridging USDC or USDT and using the standard 9 decimals on Fuel
+    #[tokio::test]
+    async fn deposit_to_wallet_with_6_decimals_and_conversion() {
+        let mut wallet: fuels::accounts::wallet::WalletUnlocked = create_wallet();
+        let proxy_token_decimals = 9u8;
+        let bridged_token_decimals = 6u8;
+        let config = BridgingConfig::new(bridged_token_decimals, proxy_token_decimals);
+
+        let configurables: Option<BridgeFungibleTokenContractConfigurables> = Some(
+            BridgeFungibleTokenContractConfigurables::new()
+                .with_DECIMALS(proxy_token_decimals)
+                .with_BRIDGED_TOKEN_DECIMALS(bridged_token_decimals)
+                .with_BRIDGED_TOKEN_GATEWAY(Bits256::from_hex_str(BRIDGED_TOKEN_GATEWAY).unwrap())
+                .with_BRIDGED_TOKEN(Bits256::from_hex_str(BRIDGED_TOKEN).unwrap())
+                .with_NAME(SizedAsciiString::<64>::new(String::from("MY_TOKEN                                                        ")).unwrap())
+                .with_SYMBOL(SizedAsciiString::<32>::new(String::from("MYTKN                           ")).unwrap())
+        );
+        
+        let deposit_amount = config.amount.min;
+
+        let (message, coin, deposit_contract) = create_msg_data(
+            BRIDGED_TOKEN,
+            BRIDGED_TOKEN_ID,
+            FROM,
+            *wallet.address().hash(),
+            deposit_amount,
+            configurables.clone(),
+            false,
+            None,
+        )
+        .await;
+        
+        let (bridge, utxo_inputs) = setup_environment(
+            &mut wallet,
+            vec![coin],
+            vec![message],
+            deposit_contract,
+            None,
+            configurables,
+        )
+        .await;
+
+        let provider = wallet.provider().expect("Needs provider");
+
+        let decimals = decimals(&bridge, get_asset_id(bridge.contract_id())).await;
+        dbg!(decimals);
+
+        let decimals = &bridge
+        .methods()
+        .bridged_token_decimals()
+        .call()
+        .await
+        .unwrap()
+        .value;
+
+        dbg!(decimals);
+
+        // Relay the test message to the bridge contract
+        let tx = relay_message_to_contract(
+            &wallet,
+            utxo_inputs.message[0].clone(),
+            utxo_inputs.contract,
+        )
+        .await;
+
+        let receipts = provider.tx_status(&tx).await.unwrap().take_receipts();
+        dbg!(&receipts);
+
+        let refund_registered_events = bridge
+            .log_decoder()
+            .decode_logs_with_type::<RefundRegisteredEvent>(&receipts)
+            .unwrap();
+
+        assert_eq!(refund_registered_events.len(), 0);
+
+        let asset_balance =
+            contract_balance(provider, bridge.contract_id(), AssetId::default()).await;
+        let balance = wallet_balance(&wallet, &get_asset_id(bridge.contract_id())).await;
+
+        // Verify the message value was received by the bridge
+        assert_eq!(asset_balance, MESSAGE_AMOUNT);
+
+        // Check that wallet now has bridged coins
+        assert_eq!(balance, config.fuel_equivalent_amount(deposit_amount));
+    }
+
     #[tokio::test]
     async fn deposit_to_wallet_max_amount() {
         let mut wallet = create_wallet();

packages/fungible-token/bridge-fungible-token/tests/utils/setup.rs

@@ -41,30 +41,35 @@ abigen!(
 );
 
 /// Used for setting up tests with various message values
+#[derive(Debug)]
 pub struct BridgingConfig {
     pub adjustment: Adjustment,
     pub amount: TxAmount,
     pub overflow: Overflow,
 }
 
+#[derive(Debug)]
 pub struct Adjustment {
     pub factor: Unsigned256,
     pub is_div: bool,
 }
 
+#[derive(Debug)]
 pub struct TxAmount {
     pub min: Unsigned256,
     pub max: Unsigned256,
     pub test: Unsigned256,
     pub not_enough: Unsigned256,
 }
 
+#[derive(Debug)]
 pub struct Overflow {
     pub one: Unsigned256,
     pub two: Unsigned256,
     pub three: Unsigned256,
 }
 
+#[derive(Debug)]
 pub struct UTXOInputs {
     pub contract: Vec<Input>,
     pub coin: Vec<Input>,
@@ -139,6 +144,8 @@ impl BridgingConfig {
     }
 
     pub fn fuel_equivalent_amount(&self, amount: Unsigned256) -> u64 {
+        dbg!(amount);
+        dbg!(&self.adjustment);
         if self.adjustment.is_div {
             (amount * self.adjustment.factor).as_u64()
         } else {
@@ -215,6 +222,8 @@ pub(crate) async fn setup_environment(
         None => LoadConfiguration::default(),
     };
 
+    dbg!(&load_configuration);
+
     let test_contract_id =
         Contract::load_from(BRIDGE_FUNGIBLE_TOKEN_CONTRACT_BINARY, load_configuration)
             .unwrap()