1054 lines
34 KiB
Plaintext
1054 lines
34 KiB
Plaintext
// SPDX-License-Identifier: Apache 2
|
|
|
|
/// This module implements three methods: `prepare_transfer` and
|
|
/// `transfer_tokens`, which are meant to work together.
|
|
///
|
|
/// `prepare_transfer` allows a contract to pack token transfer parameters in
|
|
/// preparation to bridge these assets to another network. Anyone can call this
|
|
/// method to create `TransferTicket`.
|
|
///
|
|
/// `transfer_tokens` unpacks the `TransferTicket` and constructs a
|
|
/// `MessageTicket`, which will be used by Wormhole's `publish_message`
|
|
/// module.
|
|
///
|
|
/// The purpose of splitting this token transferring into two steps is in case
|
|
/// Token Bridge needs to be upgraded and there is a breaking change for this
|
|
/// module, an integrator would not be left broken. It is discouraged to put
|
|
/// `transfer_tokens` in an integrator's package logic. Otherwise, this
|
|
/// integrator needs to be prepared to upgrade his contract to handle the latest
|
|
/// version of `transfer_tokens`.
|
|
///
|
|
/// Instead, an integrator is encouraged to execute a transaction block, which
|
|
/// executes `transfer_tokens` using the latest Token Bridge package ID and to
|
|
/// implement `prepare_transfer` in his contract to produce `PrepareTransfer`.
|
|
///
|
|
/// NOTE: Only assets that exist in the `TokenRegistry` can be bridged out,
|
|
/// which are native Sui assets that have been attested for via `attest_token`
|
|
/// and wrapped foreign assets that have been created using foreign asset
|
|
/// metadata via the `create_wrapped` module.
|
|
///
|
|
/// See `transfer` module for serialization and deserialization of Wormhole
|
|
/// message payload.
|
|
module token_bridge::transfer_tokens {
|
|
use sui::balance::{Self, Balance};
|
|
use sui::coin::{Self, Coin};
|
|
use wormhole::bytes32::{Self};
|
|
use wormhole::external_address::{Self, ExternalAddress};
|
|
use wormhole::publish_message::{MessageTicket};
|
|
|
|
use token_bridge::native_asset::{Self};
|
|
use token_bridge::normalized_amount::{Self, NormalizedAmount};
|
|
use token_bridge::state::{Self, State, LatestOnly};
|
|
use token_bridge::token_registry::{Self, VerifiedAsset};
|
|
use token_bridge::transfer::{Self};
|
|
use token_bridge::wrapped_asset::{Self};
|
|
|
|
friend token_bridge::transfer_tokens_with_payload;
|
|
|
|
/// Relayer fee exceeds `Coin` object's value.
|
|
const E_RELAYER_FEE_EXCEEDS_AMOUNT: u64 = 0;
|
|
|
|
/// This type represents transfer data for a recipient on a foreign chain.
|
|
/// The only way to destroy this type is calling `transfer_tokens`.
|
|
///
|
|
/// NOTE: An integrator that expects to bridge assets between his contracts
|
|
/// should probably use the `transfer_tokens_with_payload` module, which
|
|
/// expects a specific redeemer to complete the transfer (transfers sent
|
|
/// using `transfer_tokens` can be redeemed by anyone on behalf of the
|
|
/// encoded recipient).
|
|
struct TransferTicket<phantom CoinType> {
|
|
asset_info: VerifiedAsset<CoinType>,
|
|
bridged_in: Balance<CoinType>,
|
|
norm_amount: NormalizedAmount,
|
|
recipient_chain: u16,
|
|
recipient: vector<u8>,
|
|
relayer_fee: u64,
|
|
nonce: u32
|
|
}
|
|
|
|
/// `prepare_transfer` constructs token transfer parameters. Any remaining
|
|
/// amount (A.K.A. dust) from the funds provided will be returned along with
|
|
/// the `TransferTicket` type. The returned coin object is the same object
|
|
/// moved into this method.
|
|
///
|
|
/// NOTE: Integrators of Token Bridge should be calling only this method
|
|
/// from their contracts. This method is not guarded by version control
|
|
/// (thus not requiring a reference to the Token Bridge `State` object), so
|
|
/// it is intended to work for any package version.
|
|
public fun prepare_transfer<CoinType>(
|
|
asset_info: VerifiedAsset<CoinType>,
|
|
funded: Coin<CoinType>,
|
|
recipient_chain: u16,
|
|
recipient: vector<u8>,
|
|
relayer_fee: u64,
|
|
nonce: u32
|
|
): (
|
|
TransferTicket<CoinType>,
|
|
Coin<CoinType>
|
|
) {
|
|
let (
|
|
bridged_in,
|
|
norm_amount
|
|
) = take_truncated_amount(&asset_info, &mut funded);
|
|
|
|
let ticket =
|
|
TransferTicket {
|
|
asset_info,
|
|
bridged_in,
|
|
norm_amount,
|
|
relayer_fee,
|
|
recipient_chain,
|
|
recipient,
|
|
nonce
|
|
};
|
|
|
|
// The remaining amount of funded may have dust depending on the
|
|
// decimals of this asset.
|
|
(ticket, funded)
|
|
}
|
|
|
|
/// `transfer_tokens` is the only method that can unpack the members of
|
|
/// `TransferTicket`. This method takes the balance from this type and
|
|
/// bridges this asset out of Sui by either joining its balance in the Token
|
|
/// Bridge's custody for native assets or burning its balance for wrapped
|
|
/// assets.
|
|
///
|
|
/// A `relayer_fee` of some value less than or equal to the bridged balance
|
|
/// can be specified to incentivize someone to redeem this transfer on
|
|
/// behalf of the `recipient`.
|
|
///
|
|
/// This method returns the prepared Wormhole message (which should be
|
|
/// consumed by calling `publish_message` in a transaction block).
|
|
///
|
|
/// NOTE: This method is guarded by a minimum build version check. This
|
|
/// method could break backward compatibility on an upgrade.
|
|
///
|
|
/// It is important for integrators to refrain from calling this method
|
|
/// within their contracts. This method is meant to be called in a
|
|
/// tranasction block after receiving a `TransferTicket` from calling
|
|
/// `prepare_transfer` within a contract. If in a circumstance where this
|
|
/// module has a breaking change in an upgrade, `prepare_transfer` will not
|
|
/// be affected by this change.
|
|
public fun transfer_tokens<CoinType>(
|
|
token_bridge_state: &mut State,
|
|
ticket: TransferTicket<CoinType>
|
|
): MessageTicket {
|
|
// This capability ensures that the current build version is used.
|
|
let latest_only = state::assert_latest_only(token_bridge_state);
|
|
|
|
let (
|
|
nonce,
|
|
encoded_transfer
|
|
) =
|
|
bridge_in_and_serialize_transfer(
|
|
&latest_only,
|
|
token_bridge_state,
|
|
ticket
|
|
);
|
|
|
|
// Prepare Wormhole message with encoded `Transfer`.
|
|
state::prepare_wormhole_message(
|
|
&latest_only,
|
|
token_bridge_state,
|
|
nonce,
|
|
encoded_transfer
|
|
)
|
|
}
|
|
|
|
/// Modify coin based on the decimals of a given coin type, which may
|
|
/// leave some amount if the decimals lead to truncating the coin's balance.
|
|
/// This method returns the extracted balance (which will be bridged out of
|
|
/// Sui) and the normalized amount, which will be encoded in the token
|
|
/// transfer payload.
|
|
///
|
|
/// NOTE: This is a privileged method, which only this and the
|
|
/// `transfer_tokens_with_payload` modules can use.
|
|
public(friend) fun take_truncated_amount<CoinType>(
|
|
asset_info: &VerifiedAsset<CoinType>,
|
|
funded: &mut Coin<CoinType>
|
|
): (
|
|
Balance<CoinType>,
|
|
NormalizedAmount
|
|
) {
|
|
// Calculate dust. If there is any, `bridged_in` will have remaining
|
|
// value after split. `norm_amount` is copied since it is denormalized
|
|
// at this step.
|
|
let decimals = token_registry::coin_decimals(asset_info);
|
|
let norm_amount =
|
|
normalized_amount::from_raw(coin::value(funded), decimals);
|
|
|
|
// Split the `bridged_in` coin object to return any dust remaining on
|
|
// that object. Only bridge in the adjusted amount after de-normalizing
|
|
// the normalized amount.
|
|
let truncated =
|
|
balance::split(
|
|
coin::balance_mut(funded),
|
|
normalized_amount::to_raw(norm_amount, decimals)
|
|
);
|
|
|
|
(truncated, norm_amount)
|
|
}
|
|
|
|
/// For a given coin type, either burn Token Bridge wrapped assets or
|
|
/// deposit coin into Token Bridge's custody. This method returns the
|
|
/// canonical token info (chain ID and address), which will be encoded in
|
|
/// the token transfer.
|
|
///
|
|
/// NOTE: This is a privileged method, which only this and the
|
|
/// `transfer_tokens_with_payload` modules can use.
|
|
public(friend) fun burn_or_deposit_funds<CoinType>(
|
|
latest_only: &LatestOnly,
|
|
token_bridge_state: &mut State,
|
|
asset_info: &VerifiedAsset<CoinType>,
|
|
bridged_in: Balance<CoinType>
|
|
): (
|
|
u16,
|
|
ExternalAddress
|
|
) {
|
|
// Either burn or deposit depending on `CoinType`.
|
|
let registry =
|
|
state::borrow_mut_token_registry(latest_only, token_bridge_state);
|
|
if (token_registry::is_wrapped(asset_info)) {
|
|
wrapped_asset::burn(
|
|
token_registry::borrow_mut_wrapped(registry),
|
|
bridged_in
|
|
);
|
|
} else {
|
|
native_asset::deposit(
|
|
token_registry::borrow_mut_native(registry),
|
|
bridged_in
|
|
);
|
|
};
|
|
|
|
// Return canonical token info.
|
|
(
|
|
token_registry::token_chain(asset_info),
|
|
token_registry::token_address(asset_info)
|
|
)
|
|
}
|
|
|
|
fun bridge_in_and_serialize_transfer<CoinType>(
|
|
latest_only: &LatestOnly,
|
|
token_bridge_state: &mut State,
|
|
ticket: TransferTicket<CoinType>
|
|
): (
|
|
u32,
|
|
vector<u8>
|
|
) {
|
|
let TransferTicket {
|
|
asset_info,
|
|
bridged_in,
|
|
norm_amount,
|
|
recipient_chain,
|
|
recipient,
|
|
relayer_fee,
|
|
nonce
|
|
} = ticket;
|
|
|
|
// Disallow `relayer_fee` to be greater than the `Coin` object's value.
|
|
// Keep in mind that the relayer fee is evaluated against the truncated
|
|
// amount.
|
|
let amount = sui::balance::value(&bridged_in);
|
|
assert!(relayer_fee <= amount, E_RELAYER_FEE_EXCEEDS_AMOUNT);
|
|
|
|
// Handle funds and get canonical token info for encoded transfer.
|
|
let (
|
|
token_chain,
|
|
token_address
|
|
) = burn_or_deposit_funds(
|
|
latest_only,
|
|
token_bridge_state,
|
|
&asset_info, bridged_in
|
|
);
|
|
|
|
// Ensure that the recipient is a 32-byte address.
|
|
let recipient = external_address::new(bytes32::from_bytes(recipient));
|
|
|
|
// Finally encode `Transfer`.
|
|
let encoded =
|
|
transfer::serialize(
|
|
transfer::new(
|
|
norm_amount,
|
|
token_address,
|
|
token_chain,
|
|
recipient,
|
|
recipient_chain,
|
|
normalized_amount::from_raw(
|
|
relayer_fee,
|
|
token_registry::coin_decimals(&asset_info)
|
|
)
|
|
)
|
|
);
|
|
|
|
(nonce, encoded)
|
|
}
|
|
|
|
#[test_only]
|
|
public fun bridge_in_and_serialize_transfer_test_only<CoinType>(
|
|
token_bridge_state: &mut State,
|
|
ticket: TransferTicket<CoinType>
|
|
): (
|
|
u32,
|
|
vector<u8>
|
|
) {
|
|
// This capability ensures that the current build version is used.
|
|
let latest_only = state::assert_latest_only(token_bridge_state);
|
|
|
|
bridge_in_and_serialize_transfer(
|
|
&latest_only,
|
|
token_bridge_state,
|
|
ticket
|
|
)
|
|
}
|
|
}
|
|
|
|
#[test_only]
|
|
module token_bridge::transfer_token_tests {
|
|
use sui::coin::{Self};
|
|
use sui::test_scenario::{Self};
|
|
use wormhole::bytes32::{Self};
|
|
use wormhole::external_address::{Self};
|
|
use wormhole::publish_message::{Self};
|
|
use wormhole::state::{chain_id};
|
|
|
|
use token_bridge::coin_native_10::{Self, COIN_NATIVE_10};
|
|
use token_bridge::coin_wrapped_7::{Self, COIN_WRAPPED_7};
|
|
use token_bridge::native_asset::{Self};
|
|
use token_bridge::normalized_amount::{Self};
|
|
use token_bridge::state::{Self};
|
|
use token_bridge::token_bridge_scenario::{
|
|
set_up_wormhole_and_token_bridge,
|
|
register_dummy_emitter,
|
|
return_state,
|
|
take_state,
|
|
person
|
|
};
|
|
use token_bridge::token_registry::{Self};
|
|
use token_bridge::transfer::{Self};
|
|
use token_bridge::transfer_tokens::{Self};
|
|
use token_bridge::wrapped_asset::{Self};
|
|
|
|
/// Test consts.
|
|
const TEST_TARGET_RECIPIENT: vector<u8> = x"beef4269";
|
|
const TEST_TARGET_CHAIN: u16 = 2;
|
|
const TEST_NONCE: u32 = 0;
|
|
const TEST_COIN_NATIVE_10_DECIMALS: u8 = 10;
|
|
const TEST_COIN_WRAPPED_7_DECIMALS: u8 = 7;
|
|
|
|
#[test]
|
|
fun test_transfer_tokens_native_10() {
|
|
use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens};
|
|
|
|
let sender = person();
|
|
let my_scenario = test_scenario::begin(sender);
|
|
let scenario = &mut my_scenario;
|
|
|
|
// Set up contracts.
|
|
let wormhole_fee = 350;
|
|
set_up_wormhole_and_token_bridge(scenario, wormhole_fee);
|
|
|
|
// Register foreign emitter on chain ID == 2.
|
|
register_dummy_emitter(scenario, TEST_TARGET_CHAIN);
|
|
|
|
// Register and mint coins.
|
|
let transfer_amount = 6942000;
|
|
let coin_10_balance =
|
|
coin_native_10::init_register_and_mint(
|
|
scenario,
|
|
sender,
|
|
transfer_amount
|
|
);
|
|
|
|
// Ignore effects.
|
|
test_scenario::next_tx(scenario, sender);
|
|
|
|
// Fetch objects necessary for sending the transfer.
|
|
let token_bridge_state = take_state(scenario);
|
|
|
|
// Define the relayer fee.
|
|
let relayer_fee = 100000;
|
|
|
|
// Balance check the Token Bridge before executing the transfer. The
|
|
// initial balance should be zero for COIN_NATIVE_10.
|
|
{
|
|
let registry = state::borrow_token_registry(&token_bridge_state);
|
|
let asset = token_registry::borrow_native<COIN_NATIVE_10>(registry);
|
|
assert!(native_asset::custody(asset) == 0, 0);
|
|
};
|
|
|
|
let asset_info = state::verified_asset(&token_bridge_state);
|
|
let (
|
|
ticket,
|
|
dust
|
|
) =
|
|
prepare_transfer(
|
|
asset_info,
|
|
coin::from_balance(
|
|
coin_10_balance,
|
|
test_scenario::ctx(scenario)
|
|
),
|
|
TEST_TARGET_CHAIN,
|
|
TEST_TARGET_RECIPIENT,
|
|
relayer_fee,
|
|
TEST_NONCE,
|
|
);
|
|
coin::destroy_zero(dust);
|
|
|
|
// Call `transfer_tokens`.
|
|
let prepared_msg =
|
|
transfer_tokens(&mut token_bridge_state, ticket);
|
|
|
|
// Balance check the Token Bridge after executing the transfer. The
|
|
// balance should now reflect the `transfer_amount` defined in this
|
|
// test.
|
|
{
|
|
let registry = state::borrow_token_registry(&token_bridge_state);
|
|
let asset = token_registry::borrow_native<COIN_NATIVE_10>(registry);
|
|
assert!(native_asset::custody(asset) == transfer_amount, 0);
|
|
};
|
|
|
|
// Clean up.
|
|
publish_message::destroy(prepared_msg);
|
|
return_state(token_bridge_state);
|
|
|
|
// Done.
|
|
test_scenario::end(my_scenario);
|
|
}
|
|
|
|
#[test]
|
|
fun test_transfer_tokens_native_10_with_dust_refund() {
|
|
use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens};
|
|
|
|
let sender = person();
|
|
let my_scenario = test_scenario::begin(sender);
|
|
let scenario = &mut my_scenario;
|
|
|
|
// Set up contracts.
|
|
let wormhole_fee = 350;
|
|
set_up_wormhole_and_token_bridge(scenario, wormhole_fee);
|
|
|
|
// Register foreign emitter on chain ID == 2.
|
|
register_dummy_emitter(scenario, TEST_TARGET_CHAIN);
|
|
|
|
// Register and mint coins.
|
|
let transfer_amount = 1000069;
|
|
let coin_10_balance =
|
|
coin_native_10::init_register_and_mint(
|
|
scenario,
|
|
sender,
|
|
transfer_amount
|
|
);
|
|
|
|
// This value will be used later. The contract should return dust
|
|
// to the caller since COIN_NATIVE_10 has 10 decimals.
|
|
let expected_dust = 69;
|
|
|
|
// Ignore effects.
|
|
test_scenario::next_tx(scenario, sender);
|
|
|
|
// Fetch objects necessary for sending the transfer.
|
|
let token_bridge_state = take_state(scenario);
|
|
|
|
// Define the relayer fee.
|
|
let relayer_fee = 100000;
|
|
|
|
// Balance check the Token Bridge before executing the transfer. The
|
|
// initial balance should be zero for COIN_NATIVE_10.
|
|
{
|
|
let registry = state::borrow_token_registry(&token_bridge_state);
|
|
let asset = token_registry::borrow_native<COIN_NATIVE_10>(registry);
|
|
assert!(native_asset::custody(asset) == 0, 0);
|
|
};
|
|
|
|
let asset_info = state::verified_asset(&token_bridge_state);
|
|
let (
|
|
ticket,
|
|
dust
|
|
) =
|
|
prepare_transfer(
|
|
asset_info,
|
|
coin::from_balance(
|
|
coin_10_balance,
|
|
test_scenario::ctx(scenario)
|
|
),
|
|
TEST_TARGET_CHAIN,
|
|
TEST_TARGET_RECIPIENT,
|
|
relayer_fee,
|
|
TEST_NONCE,
|
|
);
|
|
assert!(coin::value(&dust) == expected_dust, 0);
|
|
|
|
// Call `transfer_tokens`.
|
|
let prepared_msg =
|
|
transfer_tokens(&mut token_bridge_state, ticket);
|
|
|
|
// Balance check the Token Bridge after executing the transfer. The
|
|
// balance should now reflect the `transfer_amount` less `expected_dust`
|
|
// defined in this test.
|
|
{
|
|
let registry = state::borrow_token_registry(&token_bridge_state);
|
|
let asset = token_registry::borrow_native<COIN_NATIVE_10>(registry);
|
|
assert!(
|
|
native_asset::custody(asset) == transfer_amount - expected_dust,
|
|
0
|
|
);
|
|
};
|
|
|
|
// Clean up.
|
|
publish_message::destroy(prepared_msg);
|
|
coin::burn_for_testing(dust);
|
|
return_state(token_bridge_state);
|
|
|
|
// Done.
|
|
test_scenario::end(my_scenario);
|
|
}
|
|
|
|
#[test]
|
|
fun test_serialize_transfer_tokens_native_10() {
|
|
use token_bridge::transfer_tokens::{
|
|
bridge_in_and_serialize_transfer_test_only,
|
|
prepare_transfer
|
|
};
|
|
|
|
let sender = person();
|
|
let my_scenario = test_scenario::begin(sender);
|
|
let scenario = &mut my_scenario;
|
|
|
|
// Set up contracts.
|
|
let wormhole_fee = 350;
|
|
set_up_wormhole_and_token_bridge(scenario, wormhole_fee);
|
|
|
|
// Register foreign emitter on chain ID == 2.
|
|
register_dummy_emitter(scenario, TEST_TARGET_CHAIN);
|
|
|
|
// Register and mint coins.
|
|
let transfer_amount = 6942000;
|
|
let bridged_coin_10 =
|
|
coin::from_balance(
|
|
coin_native_10::init_register_and_mint(
|
|
scenario,
|
|
sender,
|
|
transfer_amount
|
|
),
|
|
test_scenario::ctx(scenario)
|
|
);
|
|
|
|
// Ignore effects.
|
|
test_scenario::next_tx(scenario, sender);
|
|
|
|
// Fetch objects necessary for sending the transfer.
|
|
let token_bridge_state = take_state(scenario);
|
|
|
|
// Define the relayer fee.
|
|
let relayer_fee = 100000;
|
|
|
|
let asset_info = state::verified_asset(&token_bridge_state);
|
|
let expected_token_address = token_registry::token_address(&asset_info);
|
|
|
|
let (
|
|
ticket,
|
|
dust
|
|
) =
|
|
prepare_transfer(
|
|
asset_info,
|
|
bridged_coin_10,
|
|
TEST_TARGET_CHAIN,
|
|
TEST_TARGET_RECIPIENT,
|
|
relayer_fee,
|
|
TEST_NONCE,
|
|
);
|
|
coin::destroy_zero(dust);
|
|
|
|
// Call `transfer_tokens`.
|
|
let (
|
|
nonce,
|
|
payload
|
|
) =
|
|
bridge_in_and_serialize_transfer_test_only(
|
|
&mut token_bridge_state,
|
|
ticket
|
|
);
|
|
assert!(nonce == TEST_NONCE, 0);
|
|
|
|
// Construct expected payload from scratch and confirm that the
|
|
// `transfer_tokens` call produces the same payload.
|
|
let expected_amount =
|
|
normalized_amount::from_raw(
|
|
transfer_amount,
|
|
TEST_COIN_NATIVE_10_DECIMALS
|
|
);
|
|
let expected_relayer_fee =
|
|
normalized_amount::from_raw(
|
|
relayer_fee,
|
|
TEST_COIN_NATIVE_10_DECIMALS
|
|
);
|
|
|
|
let expected_payload =
|
|
transfer::new_test_only(
|
|
expected_amount,
|
|
expected_token_address,
|
|
chain_id(),
|
|
external_address::new(
|
|
bytes32::from_bytes(TEST_TARGET_RECIPIENT)
|
|
),
|
|
TEST_TARGET_CHAIN,
|
|
expected_relayer_fee
|
|
);
|
|
assert!(transfer::serialize_test_only(expected_payload) == payload, 0);
|
|
|
|
// Clean up.
|
|
return_state(token_bridge_state);
|
|
|
|
// Done.
|
|
test_scenario::end(my_scenario);
|
|
}
|
|
|
|
#[test]
|
|
fun test_transfer_tokens_wrapped_7() {
|
|
use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens};
|
|
|
|
let sender = person();
|
|
let my_scenario = test_scenario::begin(sender);
|
|
let scenario = &mut my_scenario;
|
|
|
|
// Set up contracts.
|
|
let wormhole_fee = 350;
|
|
set_up_wormhole_and_token_bridge(scenario, wormhole_fee);
|
|
|
|
// Register foreign emitter on chain ID == 2.
|
|
register_dummy_emitter(scenario, TEST_TARGET_CHAIN);
|
|
|
|
// Register and mint coins.
|
|
let transfer_amount = 42069000;
|
|
let coin_7_balance =
|
|
coin_wrapped_7::init_register_and_mint(
|
|
scenario,
|
|
sender,
|
|
transfer_amount
|
|
);
|
|
|
|
// Ignore effects.
|
|
test_scenario::next_tx(scenario, sender);
|
|
|
|
// Fetch objects necessary for sending the transfer.
|
|
let token_bridge_state = take_state(scenario);
|
|
|
|
// Define the relayer fee.
|
|
let relayer_fee = 100000;
|
|
|
|
// Balance check the Token Bridge before executing the transfer. The
|
|
// initial balance should be the `transfer_amount` for COIN_WRAPPED_7.
|
|
{
|
|
let registry = state::borrow_token_registry(&token_bridge_state);
|
|
let asset =
|
|
token_registry::borrow_wrapped<COIN_WRAPPED_7>(registry);
|
|
assert!(wrapped_asset::total_supply(asset) == transfer_amount, 0);
|
|
};
|
|
|
|
let asset_info = state::verified_asset(&token_bridge_state);
|
|
let (
|
|
ticket,
|
|
dust
|
|
) =
|
|
prepare_transfer(
|
|
asset_info,
|
|
coin::from_balance(
|
|
coin_7_balance,
|
|
test_scenario::ctx(scenario)
|
|
),
|
|
TEST_TARGET_CHAIN,
|
|
TEST_TARGET_RECIPIENT,
|
|
relayer_fee,
|
|
TEST_NONCE,
|
|
);
|
|
coin::destroy_zero(dust);
|
|
|
|
// Call `transfer_tokens`.
|
|
let prepared_msg =
|
|
transfer_tokens(&mut token_bridge_state, ticket);
|
|
|
|
// Balance check the Token Bridge after executing the transfer. The
|
|
// balance should be zero, since tokens are burned when an outbound
|
|
// wrapped token transfer occurs.
|
|
{
|
|
let registry = state::borrow_token_registry(&token_bridge_state);
|
|
let asset = token_registry::borrow_wrapped<COIN_WRAPPED_7>(registry);
|
|
assert!(wrapped_asset::total_supply(asset) == 0, 0);
|
|
};
|
|
|
|
// Clean up.
|
|
publish_message::destroy(prepared_msg);
|
|
return_state(token_bridge_state);
|
|
|
|
// Done.
|
|
test_scenario::end(my_scenario);
|
|
}
|
|
|
|
#[test]
|
|
fun test_serialize_transfer_tokens_wrapped_7() {
|
|
use token_bridge::transfer_tokens::{
|
|
bridge_in_and_serialize_transfer_test_only,
|
|
prepare_transfer
|
|
};
|
|
|
|
let sender = person();
|
|
let my_scenario = test_scenario::begin(sender);
|
|
let scenario = &mut my_scenario;
|
|
|
|
// Set up contracts.
|
|
let wormhole_fee = 350;
|
|
set_up_wormhole_and_token_bridge(scenario, wormhole_fee);
|
|
|
|
// Register foreign emitter on chain ID == 2.
|
|
register_dummy_emitter(scenario, TEST_TARGET_CHAIN);
|
|
|
|
// Register and mint coins.
|
|
let transfer_amount = 6942000;
|
|
let bridged_coin_7 =
|
|
coin::from_balance(
|
|
coin_wrapped_7::init_register_and_mint(
|
|
scenario,
|
|
sender,
|
|
transfer_amount
|
|
),
|
|
test_scenario::ctx(scenario)
|
|
);
|
|
|
|
// Ignore effects.
|
|
test_scenario::next_tx(scenario, sender);
|
|
|
|
// Fetch objects necessary for sending the transfer.
|
|
let token_bridge_state = take_state(scenario);
|
|
|
|
// Define the relayer fee.
|
|
let relayer_fee = 100000;
|
|
|
|
let asset_info = state::verified_asset(&token_bridge_state);
|
|
let expected_token_address = token_registry::token_address(&asset_info);
|
|
let expected_token_chain = token_registry::token_chain(&asset_info);
|
|
|
|
let (
|
|
ticket,
|
|
dust
|
|
) =
|
|
prepare_transfer(
|
|
asset_info,
|
|
bridged_coin_7,
|
|
TEST_TARGET_CHAIN,
|
|
TEST_TARGET_RECIPIENT,
|
|
relayer_fee,
|
|
TEST_NONCE,
|
|
);
|
|
coin::destroy_zero(dust);
|
|
|
|
// Call `transfer_tokens`.
|
|
let (
|
|
nonce,
|
|
payload
|
|
) =
|
|
bridge_in_and_serialize_transfer_test_only(
|
|
&mut token_bridge_state,
|
|
ticket
|
|
);
|
|
assert!(nonce == TEST_NONCE, 0);
|
|
|
|
// Construct expected payload from scratch and confirm that the
|
|
// `transfer_tokens` call produces the same payload.
|
|
let expected_amount =
|
|
normalized_amount::from_raw(
|
|
transfer_amount,
|
|
TEST_COIN_WRAPPED_7_DECIMALS
|
|
);
|
|
let expected_relayer_fee =
|
|
normalized_amount::from_raw(
|
|
relayer_fee,
|
|
TEST_COIN_WRAPPED_7_DECIMALS
|
|
);
|
|
|
|
let expected_payload =
|
|
transfer::new_test_only(
|
|
expected_amount,
|
|
expected_token_address,
|
|
expected_token_chain,
|
|
external_address::new(
|
|
bytes32::from_bytes(TEST_TARGET_RECIPIENT)
|
|
),
|
|
TEST_TARGET_CHAIN,
|
|
expected_relayer_fee
|
|
);
|
|
assert!(transfer::serialize_test_only(expected_payload) == payload, 0);
|
|
|
|
// Clean up.
|
|
return_state(token_bridge_state);
|
|
|
|
// Done.
|
|
test_scenario::end(my_scenario);
|
|
}
|
|
|
|
#[test]
|
|
#[expected_failure(abort_code = token_registry::E_UNREGISTERED)]
|
|
fun test_cannot_transfer_tokens_native_not_registered() {
|
|
use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens};
|
|
|
|
let sender = person();
|
|
let my_scenario = test_scenario::begin(sender);
|
|
let scenario = &mut my_scenario;
|
|
|
|
// Set up contracts.
|
|
let wormhole_fee = 350;
|
|
set_up_wormhole_and_token_bridge(scenario, wormhole_fee);
|
|
|
|
// Register foreign emitter on chain ID == 2.
|
|
register_dummy_emitter(scenario, TEST_TARGET_CHAIN);
|
|
|
|
// Initialize COIN_NATIVE_10 (but don't register it).
|
|
coin_native_10::init_test_only(test_scenario::ctx(scenario));
|
|
|
|
// NOTE: This test purposely doesn't `attest` COIN_NATIVE_10.
|
|
let transfer_amount = 6942000;
|
|
let test_coins =
|
|
coin::mint_for_testing<COIN_NATIVE_10>(
|
|
transfer_amount,
|
|
test_scenario::ctx(scenario)
|
|
);
|
|
|
|
// Ignore effects.
|
|
test_scenario::next_tx(scenario, sender);
|
|
|
|
// Fetch objects necessary for sending the transfer.
|
|
let token_bridge_state = take_state(scenario);
|
|
|
|
// Define the relayer fee.
|
|
let relayer_fee = 100000;
|
|
|
|
let asset_info = state::verified_asset(&token_bridge_state);
|
|
let (
|
|
ticket,
|
|
dust
|
|
) =
|
|
prepare_transfer(
|
|
asset_info,
|
|
test_coins,
|
|
TEST_TARGET_CHAIN,
|
|
TEST_TARGET_RECIPIENT,
|
|
relayer_fee,
|
|
TEST_NONCE,
|
|
);
|
|
coin::destroy_zero(dust);
|
|
|
|
// You shall not pass!
|
|
let prepared_msg =
|
|
transfer_tokens(&mut token_bridge_state, ticket);
|
|
|
|
// Clean up.
|
|
publish_message::destroy(prepared_msg);
|
|
|
|
abort 42
|
|
}
|
|
|
|
#[test]
|
|
#[expected_failure(abort_code = token_registry::E_UNREGISTERED)]
|
|
fun test_cannot_transfer_tokens_wrapped_not_registered() {
|
|
use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens};
|
|
|
|
let sender = person();
|
|
let my_scenario = test_scenario::begin(sender);
|
|
let scenario = &mut my_scenario;
|
|
|
|
// Set up contracts.
|
|
let wormhole_fee = 350;
|
|
set_up_wormhole_and_token_bridge(scenario, wormhole_fee);
|
|
|
|
// Register foreign emitter on chain ID == 2.
|
|
register_dummy_emitter(scenario, TEST_TARGET_CHAIN);
|
|
|
|
// Initialize COIN_WRAPPED_7 (but don't register it).
|
|
coin_native_10::init_test_only(test_scenario::ctx(scenario));
|
|
|
|
let treasury_cap =
|
|
coin_wrapped_7::init_and_take_treasury_cap(
|
|
scenario,
|
|
sender
|
|
);
|
|
sui::test_utils::destroy(treasury_cap);
|
|
|
|
// NOTE: This test purposely doesn't `attest` COIN_WRAPPED_7.
|
|
let transfer_amount = 42069;
|
|
let test_coins =
|
|
coin::mint_for_testing<COIN_WRAPPED_7>(
|
|
transfer_amount,
|
|
test_scenario::ctx(scenario)
|
|
);
|
|
|
|
// Ignore effects.
|
|
test_scenario::next_tx(scenario, sender);
|
|
|
|
// Fetch objects necessary for sending the transfer.
|
|
let token_bridge_state = take_state(scenario);
|
|
|
|
// Define the relayer fee.
|
|
let relayer_fee = 1000;
|
|
|
|
let asset_info = state::verified_asset(&token_bridge_state);
|
|
let (
|
|
ticket,
|
|
dust
|
|
) =
|
|
prepare_transfer(
|
|
asset_info,
|
|
test_coins,
|
|
TEST_TARGET_CHAIN,
|
|
TEST_TARGET_RECIPIENT,
|
|
relayer_fee,
|
|
TEST_NONCE,
|
|
);
|
|
coin::destroy_zero(dust);
|
|
|
|
// You shall not pass!
|
|
let prepared_msg =
|
|
transfer_tokens(&mut token_bridge_state, ticket);
|
|
|
|
// Clean up.
|
|
publish_message::destroy(prepared_msg);
|
|
|
|
abort 42
|
|
}
|
|
|
|
#[test]
|
|
#[expected_failure(
|
|
abort_code = transfer_tokens::E_RELAYER_FEE_EXCEEDS_AMOUNT
|
|
)]
|
|
fun test_cannot_transfer_tokens_fee_exceeds_amount() {
|
|
use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens};
|
|
|
|
let sender = person();
|
|
let my_scenario = test_scenario::begin(sender);
|
|
let scenario = &mut my_scenario;
|
|
|
|
// Set up contracts.
|
|
let wormhole_fee = 350;
|
|
set_up_wormhole_and_token_bridge(scenario, wormhole_fee);
|
|
|
|
// Register foreign emitter on chain ID == 2.
|
|
register_dummy_emitter(scenario, TEST_TARGET_CHAIN);
|
|
|
|
// NOTE: The `relayer_fee` is intentionally set to a higher number
|
|
// than the `transfer_amount`.
|
|
let relayer_fee = 100001;
|
|
let transfer_amount = 100000;
|
|
let coin_10_balance =
|
|
coin_native_10::init_register_and_mint(
|
|
scenario,
|
|
sender,
|
|
transfer_amount
|
|
);
|
|
|
|
// Ignore effects.
|
|
test_scenario::next_tx(scenario, sender);
|
|
|
|
// Fetch objects necessary for sending the transfer.
|
|
let token_bridge_state = take_state(scenario);
|
|
|
|
let asset_info = state::verified_asset(&token_bridge_state);
|
|
let (
|
|
ticket,
|
|
dust
|
|
) =
|
|
prepare_transfer(
|
|
asset_info,
|
|
coin::from_balance(
|
|
coin_10_balance,
|
|
test_scenario::ctx(scenario)
|
|
),
|
|
TEST_TARGET_CHAIN,
|
|
TEST_TARGET_RECIPIENT,
|
|
relayer_fee,
|
|
TEST_NONCE,
|
|
);
|
|
coin::destroy_zero(dust);
|
|
|
|
// You shall not pass!
|
|
let prepared_msg =
|
|
transfer_tokens(&mut token_bridge_state, ticket);
|
|
|
|
// Done.
|
|
publish_message::destroy(prepared_msg);
|
|
|
|
abort 42
|
|
}
|
|
|
|
#[test]
|
|
#[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)]
|
|
fun test_cannot_transfer_tokens_outdated_version() {
|
|
use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens};
|
|
|
|
let sender = person();
|
|
let my_scenario = test_scenario::begin(sender);
|
|
let scenario = &mut my_scenario;
|
|
|
|
// Set up contracts.
|
|
let wormhole_fee = 350;
|
|
set_up_wormhole_and_token_bridge(scenario, wormhole_fee);
|
|
|
|
// Register foreign emitter on chain ID == 2.
|
|
register_dummy_emitter(scenario, TEST_TARGET_CHAIN);
|
|
|
|
// Register and mint coins.
|
|
let transfer_amount = 6942000;
|
|
let coin_10_balance =
|
|
coin_native_10::init_register_and_mint(
|
|
scenario,
|
|
sender,
|
|
transfer_amount
|
|
);
|
|
|
|
// Ignore effects.
|
|
test_scenario::next_tx(scenario, sender);
|
|
|
|
// Fetch objects necessary for sending the transfer.
|
|
let token_bridge_state = take_state(scenario);
|
|
|
|
let asset_info = state::verified_asset(&token_bridge_state);
|
|
|
|
let relayer_fee = 0;
|
|
|
|
let (
|
|
ticket,
|
|
dust
|
|
) =
|
|
prepare_transfer(
|
|
asset_info,
|
|
coin::from_balance(
|
|
coin_10_balance,
|
|
test_scenario::ctx(scenario)
|
|
),
|
|
TEST_TARGET_CHAIN,
|
|
TEST_TARGET_RECIPIENT,
|
|
relayer_fee,
|
|
TEST_NONCE,
|
|
);
|
|
coin::destroy_zero(dust);
|
|
|
|
// Conveniently roll version back.
|
|
state::reverse_migrate_version(&mut token_bridge_state);
|
|
|
|
// Simulate executing with an outdated build by upticking the minimum
|
|
// required version for `publish_message` to something greater than
|
|
// this build.
|
|
state::migrate_version_test_only(
|
|
&mut token_bridge_state,
|
|
token_bridge::version_control::previous_version_test_only(),
|
|
token_bridge::version_control::next_version()
|
|
);
|
|
|
|
// You shall not pass!
|
|
let prepared_msg =
|
|
transfer_tokens(&mut token_bridge_state, ticket);
|
|
|
|
// Clean up.
|
|
publish_message::destroy(prepared_msg);
|
|
|
|
abort 42
|
|
}
|
|
}
|