Skip to content

Commit 184069f

Browse files
DefiCakeDefiCake
committed
feat: workaround current fuel-rs issue #1265
1 parent 4acbc8c commit 184069f

File tree

6 files changed

+158
-39
lines changed

6 files changed

+158
-39
lines changed

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

+10-6
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,7 @@ use std::{
3434
hash::sha256,
3535
inputs::input_message_sender,
3636
message::send_message,
37+
primitive_conversions::u64::*,
3738
string::String,
3839
};
3940
use utils::{
@@ -45,8 +46,8 @@ use utils::{
4546
use src_20::SRC20;
4647

4748
configurable {
48-
DECIMALS: u8 = 9u8,
49-
BRIDGED_TOKEN_DECIMALS: u8 = 18u8,
49+
DECIMALS: u64 = 9u64,
50+
BRIDGED_TOKEN_DECIMALS: u64 = 18u64,
5051
BRIDGED_TOKEN_GATEWAY: b256 = 0x00000000000000000000000096c53cd98B7297564716a8f2E1de2C83928Af2fe,
5152
BRIDGED_TOKEN: b256 = 0x00000000000000000000000000000000000000000000000000000000deadbeef,
5253
NAME: str[64] = __to_str_array("MY_TOKEN "),
@@ -97,7 +98,7 @@ impl MessageReceiver for Contract {
9798
return;
9899
};
99100

100-
let res_amount = adjust_deposit_decimals(message_data.amount, DECIMALS, BRIDGED_TOKEN_DECIMALS);
101+
let res_amount = adjust_deposit_decimals(message_data.amount, DECIMALS.try_as_u8().unwrap(), BRIDGED_TOKEN_DECIMALS.try_as_u8().unwrap());
101102

102103
match res_amount {
103104
Result::Err(_) => {
@@ -229,7 +230,7 @@ impl Bridge for Contract {
229230
require(amount != 0, BridgeFungibleTokenError::NoCoinsSent);
230231

231232
// attempt to adjust amount into base layer decimals and burn the sent tokens
232-
let adjusted_amount = adjust_withdrawal_decimals(amount, DECIMALS, BRIDGED_TOKEN_DECIMALS).unwrap();
233+
let adjusted_amount = adjust_withdrawal_decimals(amount, DECIMALS.try_as_u8().unwrap(), BRIDGED_TOKEN_DECIMALS.try_as_u8().unwrap()).unwrap();
233234
storage
234235
.tokens_minted
235236
.insert(
@@ -260,7 +261,10 @@ impl Bridge for Contract {
260261
}
261262

262263
fn bridged_token_decimals() -> u8 {
263-
DECIMALS
264+
let dec = 18u64.try_as_u8().unwrap();
265+
266+
dec
267+
// DECIMALS.try_as_u8().unwrap()
264268
}
265269

266270
fn bridged_token_gateway() -> b256 {
@@ -303,7 +307,7 @@ impl SRC20 for Contract {
303307
#[storage(read)]
304308
fn decimals(asset: AssetId) -> Option<u8> {
305309
match storage.tokens_minted.get(asset).try_read() {
306-
Some(_) => Some(DECIMALS),
310+
Some(_) => Some(DECIMALS.try_as_u8().unwrap()),
307311
None => None,
308312
}
309313
}

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

+1-1
Original file line numberDiff line numberDiff line change
@@ -520,7 +520,7 @@ mod success {
520520

521521
let response = bridged_token_decimals(&contract).await;
522522

523-
assert_eq!(response, BRIDGED_TOKEN_DECIMALS)
523+
assert_eq!(u64::from(response), BRIDGED_TOKEN_DECIMALS)
524524
}
525525

526526
#[tokio::test]

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

+143-28
Original file line numberDiff line numberDiff line change
@@ -14,8 +14,8 @@ mod success {
1414
use super::*;
1515

1616
use crate::utils::constants::BRIDGED_TOKEN_GATEWAY;
17-
use crate::utils::interface::src20::{decimals, total_supply};
18-
use crate::utils::setup::{decode_hex, get_asset_id};
17+
use crate::utils::interface::src20::total_supply;
18+
use crate::utils::setup::get_asset_id;
1919
use crate::utils::{
2020
constants::MESSAGE_AMOUNT,
2121
setup::{
@@ -76,12 +76,12 @@ mod success {
7676
assert_eq!(balance, config.fuel_equivalent_amount(config.amount.test));
7777
}
7878

79-
// This test is akin to bridging WBTC and mimicking its decimals on Fuel
79+
// This test is akin to bridging USDT or USDC and mimicking its decimals on Fuel
8080
#[tokio::test]
8181
async fn deposit_to_wallet_with_6_decimals() {
8282
let mut wallet: fuels::accounts::wallet::WalletUnlocked = create_wallet();
83-
let proxy_token_decimals = 6u8;
84-
let bridged_token_decimals = 6u8;
83+
let proxy_token_decimals = 6u64;
84+
let bridged_token_decimals = 6u64;
8585
let config = BridgingConfig::new(bridged_token_decimals, proxy_token_decimals);
8686

8787
let configurables: Option<BridgeFungibleTokenContractConfigurables> = Some(
@@ -103,8 +103,6 @@ mod success {
103103
.await;
104104

105105
assert_eq!(config.amount.test.as_u64(), config.fuel_equivalent_amount(config.amount.test));
106-
dbg!(config.amount.test.as_u64());
107-
dbg!(config.fuel_equivalent_amount(config.amount.test));
108106

109107
let (bridge, utxo_inputs) = setup_environment(
110108
&mut wallet,
@@ -146,12 +144,12 @@ mod success {
146144
assert_eq!(balance, config.fuel_equivalent_amount(config.amount.test));
147145
}
148146

149-
// This test is akin to bridging USDC or USDT and mimicking its decimals on Fuel
147+
// This test is akin to bridging WBTC and mimicking its decimals on Fuel
150148
#[tokio::test]
151149
async fn deposit_to_wallet_with_8_decimals() {
152150
let mut wallet: fuels::accounts::wallet::WalletUnlocked = create_wallet();
153-
let proxy_token_decimals = 8u8;
154-
let bridged_token_decimals = 8u8;
151+
let proxy_token_decimals = 8u64;
152+
let bridged_token_decimals = 8u64;
155153
let config = BridgingConfig::new(bridged_token_decimals, proxy_token_decimals);
156154

157155
let configurables: Option<BridgeFungibleTokenContractConfigurables> = Some(
@@ -173,8 +171,6 @@ mod success {
173171
.await;
174172

175173
assert_eq!(config.amount.test.as_u64(), config.fuel_equivalent_amount(config.amount.test));
176-
dbg!(config.amount.test.as_u64());
177-
dbg!(config.fuel_equivalent_amount(config.amount.test));
178174

179175
let (bridge, utxo_inputs) = setup_environment(
180176
&mut wallet,
@@ -220,8 +216,8 @@ mod success {
220216
#[tokio::test]
221217
async fn deposit_to_wallet_with_6_decimals_and_conversion() {
222218
let mut wallet: fuels::accounts::wallet::WalletUnlocked = create_wallet();
223-
let proxy_token_decimals = 9u8;
224-
let bridged_token_decimals = 6u8;
219+
let proxy_token_decimals = 9u64;
220+
let bridged_token_decimals = 6u64;
225221
let config = BridgingConfig::new(bridged_token_decimals, proxy_token_decimals);
226222

227223
let configurables: Option<BridgeFungibleTokenContractConfigurables> = Some(
@@ -260,19 +256,6 @@ mod success {
260256

261257
let provider = wallet.provider().expect("Needs provider");
262258

263-
let decimals = decimals(&bridge, get_asset_id(bridge.contract_id())).await;
264-
dbg!(decimals);
265-
266-
let decimals = &bridge
267-
.methods()
268-
.bridged_token_decimals()
269-
.call()
270-
.await
271-
.unwrap()
272-
.value;
273-
274-
dbg!(decimals);
275-
276259
// Relay the test message to the bridge contract
277260
let tx = relay_message_to_contract(
278261
&wallet,
@@ -282,7 +265,6 @@ mod success {
282265
.await;
283266

284267
let receipts = provider.tx_status(&tx).await.unwrap().take_receipts();
285-
dbg!(&receipts);
286268

287269
let refund_registered_events = bridge
288270
.log_decoder()
@@ -302,6 +284,139 @@ mod success {
302284
assert_eq!(balance, config.fuel_equivalent_amount(deposit_amount));
303285
}
304286

287+
// This test is akin to bridging WBTC and and using the standard 9 decimals on Fuel
288+
#[tokio::test]
289+
async fn deposit_to_wallet_with_8_decimals_and_conversion() {
290+
let mut wallet: fuels::accounts::wallet::WalletUnlocked = create_wallet();
291+
let proxy_token_decimals = 9u64;
292+
let bridged_token_decimals = 8u64;
293+
let config = BridgingConfig::new(bridged_token_decimals, proxy_token_decimals);
294+
295+
let configurables: Option<BridgeFungibleTokenContractConfigurables> = Some(
296+
BridgeFungibleTokenContractConfigurables::new()
297+
.with_DECIMALS(proxy_token_decimals)
298+
.with_BRIDGED_TOKEN_DECIMALS(bridged_token_decimals)
299+
);
300+
301+
let (message, coin, deposit_contract) = create_msg_data(
302+
BRIDGED_TOKEN,
303+
BRIDGED_TOKEN_ID,
304+
FROM,
305+
*wallet.address().hash(),
306+
config.amount.test,
307+
configurables.clone(),
308+
false,
309+
None,
310+
)
311+
.await;
312+
313+
let (bridge, utxo_inputs) = setup_environment(
314+
&mut wallet,
315+
vec![coin],
316+
vec![message],
317+
deposit_contract,
318+
None,
319+
configurables,
320+
)
321+
.await;
322+
323+
let provider = wallet.provider().expect("Needs provider");
324+
325+
// Relay the test message to the bridge contract
326+
let tx = relay_message_to_contract(
327+
&wallet,
328+
utxo_inputs.message[0].clone(),
329+
utxo_inputs.contract,
330+
)
331+
.await;
332+
333+
let receipts = provider.tx_status(&tx).await.unwrap().take_receipts();
334+
335+
let refund_registered_events = bridge
336+
.log_decoder()
337+
.decode_logs_with_type::<RefundRegisteredEvent>(&receipts)
338+
.unwrap();
339+
340+
assert_eq!(refund_registered_events.len(), 0);
341+
342+
let asset_balance =
343+
contract_balance(provider, bridge.contract_id(), AssetId::default()).await;
344+
let balance = wallet_balance(&wallet, &get_asset_id(bridge.contract_id())).await;
345+
346+
// Verify the message value was received by the bridge
347+
assert_eq!(asset_balance, MESSAGE_AMOUNT);
348+
349+
// Check that wallet now has bridged coins
350+
assert_eq!(balance, config.fuel_equivalent_amount(config.amount.test));
351+
}
352+
353+
// Cannot find an example of a token that has more than 18 decimals
354+
#[tokio::test]
355+
async fn deposit_to_wallet_with_30_decimals_and_conversion() {
356+
let mut wallet: fuels::accounts::wallet::WalletUnlocked = create_wallet();
357+
let proxy_token_decimals = 9u64;
358+
let bridged_token_decimals = 30u64;
359+
let config = BridgingConfig::new(bridged_token_decimals, proxy_token_decimals);
360+
361+
let configurables: Option<BridgeFungibleTokenContractConfigurables> = Some(
362+
BridgeFungibleTokenContractConfigurables::new()
363+
.with_DECIMALS(proxy_token_decimals)
364+
.with_BRIDGED_TOKEN_DECIMALS(bridged_token_decimals)
365+
);
366+
367+
let (message, coin, deposit_contract) = create_msg_data(
368+
BRIDGED_TOKEN,
369+
BRIDGED_TOKEN_ID,
370+
FROM,
371+
*wallet.address().hash(),
372+
config.amount.test,
373+
configurables.clone(),
374+
false,
375+
None,
376+
)
377+
.await;
378+
379+
let (bridge, utxo_inputs) = setup_environment(
380+
&mut wallet,
381+
vec![coin],
382+
vec![message],
383+
deposit_contract,
384+
None,
385+
configurables,
386+
)
387+
.await;
388+
389+
let provider = wallet.provider().expect("Needs provider");
390+
391+
// Relay the test message to the bridge contract
392+
let tx = relay_message_to_contract(
393+
&wallet,
394+
utxo_inputs.message[0].clone(),
395+
utxo_inputs.contract,
396+
)
397+
.await;
398+
399+
let receipts = provider.tx_status(&tx).await.unwrap().take_receipts();
400+
401+
let refund_registered_events = bridge
402+
.log_decoder()
403+
.decode_logs_with_type::<RefundRegisteredEvent>(&receipts)
404+
.unwrap();
405+
406+
assert_eq!(refund_registered_events.len(), 0);
407+
408+
let asset_balance =
409+
contract_balance(provider, bridge.contract_id(), AssetId::default()).await;
410+
let balance = wallet_balance(&wallet, &get_asset_id(bridge.contract_id())).await;
411+
412+
// Verify the message value was received by the bridge
413+
assert_eq!(asset_balance, MESSAGE_AMOUNT);
414+
415+
// Check that wallet now has bridged coins
416+
assert_eq!(balance, config.fuel_equivalent_amount(config.amount.test));
417+
}
418+
419+
305420
#[tokio::test]
306421
async fn deposit_to_wallet_max_amount() {
307422
let mut wallet = create_wallet();

‎packages/fungible-token/bridge-fungible-token/tests/functions/src20/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,6 @@ mod success {
5757

5858
let response = decimals(&contract, asset_id).await.unwrap();
5959

60-
assert_eq!(response, PROXY_TOKEN_DECIMALS)
60+
assert_eq!(u64::from(response), PROXY_TOKEN_DECIMALS)
6161
}
6262
}

‎packages/fungible-token/bridge-fungible-token/tests/utils/constants.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -16,8 +16,8 @@ pub(crate) const BRIDGED_TOKEN_GATEWAY: &str =
1616
pub(crate) const TO: &str = "0x0000000000000000000000000000000000000000000000000000000000000777";
1717
pub(crate) const FROM: &str = "0x0000000000000000000000008888888888888888888888888888888888888888";
1818

19-
pub(crate) const BRIDGED_TOKEN_DECIMALS: u8 = 18;
20-
pub(crate) const PROXY_TOKEN_DECIMALS: u8 = 9;
19+
pub(crate) const BRIDGED_TOKEN_DECIMALS: u64 = 18;
20+
pub(crate) const PROXY_TOKEN_DECIMALS: u64 = 9;
2121
pub(crate) const PRECISION: u64 = 10u64.pow((BRIDGED_TOKEN_DECIMALS - PROXY_TOKEN_DECIMALS) as u32);
2222

2323
pub(crate) const MESSAGE_AMOUNT: u64 = 100;

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

+1-1
Original file line numberDiff line numberDiff line change
@@ -77,7 +77,7 @@ pub struct UTXOInputs {
7777
}
7878

7979
impl BridgingConfig {
80-
pub fn new(bridge_decimals: u8, proxy_decimals: u8) -> Self {
80+
pub fn new(bridge_decimals: u64, proxy_decimals: u64) -> Self {
8181
let bridged_token_decimals = Unsigned256::from(bridge_decimals);
8282
let proxy_token_decimals = Unsigned256::from(proxy_decimals);
8383
let one = Unsigned256::from(1);

0 commit comments

Comments
 (0)