Skip to content

Commit

Permalink
test: add tests for the cases found by tob
Browse files Browse the repository at this point in the history
  • Loading branch information
@DefiCake
DefiCake committed Jul 12, 2023
1 parent 0e8d172 commit b56d7a8
Show file tree
Hide file tree
Showing 2 changed files with 270 additions and 5 deletions.
258 changes: 258 additions & 0 deletions packages/fungible-token/bridge-fungible-token/tests/harness.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,6 +14,7 @@ use fuels::{
tx::Receipt,
types::Bits256,
};
use primitive_types::U256 as Unsigned256;

pub const BRIDGED_TOKEN: &str =
"0x00000000000000000000000000000000000000000000000000000000deadbeef";
Expand Down Expand Up @@ -266,6 +267,137 @@ mod success {
assert_eq!(amount, config.overflow_2);
}

#[tokio::test]
async fn claim_refund_of_wrong_token_deposit() {
// perform a failing deposit first to register a refund & verify it, then claim and verify output message is created as expected
let mut wallet = env::setup_wallet();

let configurables: Option<BridgeFungibleTokenContractConfigurables> = None;
let config = env::generate_test_config((BRIDGED_TOKEN_DECIMALS, PROXY_TOKEN_DECIMALS));
let wrong_token_value: &str =
"0x1111110000000000000000000000000000000000000000000000000000111111";

let (message, coin, deposit_contract) = env::construct_msg_data(
wrong_token_value,
FROM,
*wallet.address().hash(),
config.overflow_2,
configurables.clone(),
false,
None,
)
.await;

// Set up the environment
let (
test_contract,
contract_inputs,
coin_inputs,
message_inputs,
test_contract_id,
provider,
) = env::setup_environment(
&mut wallet,
vec![coin],
vec![message],
deposit_contract,
None,
configurables,
)
.await;

// Relay the test message to the test contract
let receipts = env::relay_message_to_contract(
&wallet,
message_inputs[0].clone(),
contract_inputs,
&coin_inputs[..],
&env::generate_variable_output(),
)
.await;

let log_decoder = test_contract.log_decoder();
let refund_registered_event = log_decoder
.decode_logs_with_type::<RefundRegisteredEvent>(&receipts)
.unwrap();

// Verify the message value was received by the test contract
let test_contract_balance = provider
.get_contract_asset_balance(test_contract.contract_id(), AssetId::default())
.await
.unwrap();
let balance = wallet
.get_asset_balance(&AssetId::new(*test_contract_id.hash()))
.await
.unwrap();

assert_eq!(test_contract_balance, 100);
assert_eq!(
refund_registered_event[0].amount,
Bits256(env::encode_hex(config.overflow_2))
);
assert_eq!(
refund_registered_event[0].asset,
Bits256::from_hex_str(wrong_token_value).unwrap()
);
assert_eq!(
refund_registered_event[0].from,
Bits256::from_hex_str(FROM).unwrap()
);

// verify that no tokens were minted for message.data.to
assert_eq!(balance, 0);

// verify that trying to claim funds from
// the correct token fails
let error_response = test_contract
.methods()
.claim_refund(
Bits256::from_hex_str(FROM).unwrap(),
Bits256::from_hex_str(BRIDGED_TOKEN).unwrap(),
)
.call()
.await;
assert!(error_response.is_err());

let call_response = test_contract
.methods()
.claim_refund(
Bits256::from_hex_str(FROM).unwrap(),
Bits256::from_hex_str(wrong_token_value).unwrap(),
)
.call()
.await
.unwrap();

// verify correct message was sent
let message_receipt = call_response
.receipts
.iter()
.find(|&r| matches!(r, Receipt::MessageOut { .. }))
.unwrap();

assert_eq!(
*test_contract_id.hash(),
**message_receipt.sender().unwrap()
);
assert_eq!(
&Address::from_str(BRIDGED_TOKEN_GATEWAY).unwrap(),
message_receipt.recipient().unwrap()
);
assert_eq!(message_receipt.amount().unwrap(), 0);
assert_eq!(message_receipt.len().unwrap(), 104);

// message data
let (selector, to, token, amount) =
env::parse_output_message_data(message_receipt.data().unwrap());
assert_eq!(selector, env::decode_hex("0x53ef1461").to_vec());
assert_eq!(to, Bits256::from_hex_str(FROM).unwrap());
assert_eq!(token, Bits256::from_hex_str(wrong_token_value).unwrap());
// Compare the value output in the message with the original value sent
assert_eq!(amount, config.overflow_2);
}

#[tokio::test]
async fn withdraw_from_bridge() {
// perform successful deposit first, verify it, then withdraw and verify balances
Expand Down Expand Up @@ -1326,4 +1458,130 @@ mod revert {
// verify that no tokens were minted for message.data.to
assert_eq!(balance, 0);
}

#[tokio::test]
async fn deposit_with_wrong_token_twice_registers_two_refunds() {
let mut wallet = env::setup_wallet();
let configurables: Option<BridgeFungibleTokenContractConfigurables> = None;
let wrong_token_value: &str =
"0x1111110000000000000000000000000000000000000000000000000000111111";

let config = env::generate_test_config((BRIDGED_TOKEN_DECIMALS, PROXY_TOKEN_DECIMALS));

let (message, coin, deposit_contract) = env::construct_msg_data(
wrong_token_value,
FROM,
*Address::from_str(TO).unwrap(),
config.min_amount,
configurables.clone(),
false,
None,
)
.await;

let one = Unsigned256::from(1);

let (message2,_,_) = env::construct_msg_data(
wrong_token_value,
FROM,
*Address::from_str(TO).unwrap(),
config.min_amount + one,
configurables.clone(),
false,
None,
)
.await;

// Set up the environment
let (
test_contract,
contract_inputs,
coin_inputs,
message_inputs,
test_contract_id,
provider,
) = env::setup_environment(
&mut wallet,
vec![coin],
vec![message, message2],
deposit_contract,
None,
configurables,
)
.await;

// Relay the test message to the test contract
let receipts = env::relay_message_to_contract(
&wallet,
message_inputs[0].clone(),
contract_inputs.clone(),
&coin_inputs[..],
&env::generate_variable_output(),
)
.await;

// Relay the test message to the test contract
let receipts_second = env::relay_message_to_contract(
&wallet,
message_inputs[1].clone(),
contract_inputs.clone(),
&coin_inputs[..],
&env::generate_variable_output(),
)
.await;

let log_decoder = test_contract.log_decoder();
let refund_registered_event = log_decoder
.decode_logs_with_type::<RefundRegisteredEvent>(&receipts)
.unwrap();

// Verify the message value was received by the test contract
let test_contract_balance = provider
.get_contract_asset_balance(test_contract.contract_id(), AssetId::default())
.await
.unwrap();

let balance = wallet
.get_asset_balance(&AssetId::new(*test_contract_id.hash()))
.await
.unwrap();

// Verify the message value was received by the test contract
assert_eq!(test_contract_balance, 200);


// check that the RefundRegisteredEvent receipt is populated correctly
assert_eq!(
refund_registered_event[0].amount,
Bits256(env::encode_hex(config.min_amount))
);
assert_eq!(
refund_registered_event[0].asset,
Bits256::from_hex_str(wrong_token_value).unwrap()
);
assert_eq!(
refund_registered_event[0].from,
Bits256::from_hex_str(FROM).unwrap()
);

// verify that no tokens were minted for message.data.to
assert_eq!(balance, 0);

// check that the RefundRegisteredEvent receipt is populated correctly
let second_refund_registered_event = log_decoder
.decode_logs_with_type::<RefundRegisteredEvent>(&receipts_second)
.unwrap();
assert_eq!(
second_refund_registered_event[0].amount,
Bits256(env::encode_hex(config.min_amount + one))
);
assert_eq!(
second_refund_registered_event[0].asset,
Bits256::from_hex_str(wrong_token_value).unwrap()
);
assert_eq!(
second_refund_registered_event[0].from,
Bits256::from_hex_str(FROM).unwrap()
);
}
}
17 changes: 12 additions & 5 deletions packages/fungible-token/bridge-fungible-token/tests/utils/environment.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,13 @@ use fuel_core_types::{
};
use fuels::{
accounts::{
fuel_crypto::SecretKey, predicate::Predicate, wallet::WalletUnlocked, Signer,
fuel_crypto::{
SecretKey,
fuel_types::Nonce
},
predicate::Predicate,
wallet::WalletUnlocked,
Signer,
ViewOnlyAccount,
},
prelude::{
Expand Down Expand Up @@ -184,8 +190,8 @@ pub async fn setup_environment(
.collect();
let all_coins = setup_custom_assets_coins(wallet.address(), &asset_configs[..]);

// Generate messages
let message_nonce = Word::default();
// Generate message
let mut message_nonce = Nonce::zeroed();
let message_sender = match sender {
Some(v) => Address::from_str(v).unwrap(),
None => Address::from_str(MESSAGE_SENDER_ADDRESS).unwrap(),
Expand All @@ -200,9 +206,10 @@ pub async fn setup_environment(
&message_sender.into(),
predicate_root,
msg.0,
message_nonce.into(),
Nonce::from(message_nonce),
msg.1.clone(),
))
));
message_nonce[0] = message_nonce[0] + 1;
}

let (provider, _) = setup_test_provider(
Expand Down

0 comments on commit b56d7a8

Please sign in to comment.