mirror of
https://github.com/serai-dex/serai.git
synced 2025-12-08 12:19:24 +00:00
Remove now-consolidated primitives crates
This commit is contained in:
Luke Parker
507
substrate/in-instructions/src/tests.rs
Normal file
507
substrate/in-instructions/src/tests.rs
Normal file
@@ -0,0 +1,507 @@
|
||||
use super::*;
|
||||
use crate::mock::*;
|
||||
|
||||
use emissions_pallet::primitives::POL_ACCOUNT;
|
||||
use genesis_liquidity_pallet::primitives::INITIAL_GENESIS_LP_SHARES;
|
||||
use scale::Encode;
|
||||
|
||||
use frame_support::{pallet_prelude::InvalidTransaction, traits::OnFinalize};
|
||||
use frame_system::RawOrigin;
|
||||
|
||||
use sp_core::{sr25519::Public, Pair};
|
||||
use sp_runtime::{traits::ValidateUnsigned, transaction_validity::TransactionSource};
|
||||
|
||||
use validator_sets::{Pallet as ValidatorSets, primitives::KeyPair};
|
||||
use coins::primitives::{OutInstruction, OutInstructionWithBalance};
|
||||
use genesis_liquidity::primitives::GENESIS_LIQUIDITY_ACCOUNT;
|
||||
|
||||
fn set_keys_for_session(key: Public) {
|
||||
for n in EXTERNAL_NETWORKS {
|
||||
ValidatorSets::<Test>::set_keys(
|
||||
RawOrigin::None.into(),
|
||||
n,
|
||||
KeyPair(key, vec![].try_into().unwrap()),
|
||||
vec![].try_into().unwrap(),
|
||||
Signature([0u8; 64]),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[expect(dead_code)]
|
||||
fn get_events() -> Vec<Event<Test>> {
|
||||
let events = System::events()
|
||||
.iter()
|
||||
.filter_map(|event| {
|
||||
if let RuntimeEvent::InInstructions(e) = &event.event {
|
||||
Some(e.clone())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
System::reset_events();
|
||||
events
|
||||
}
|
||||
|
||||
fn make_liquid_pool(coin: ExternalCoin, amount: u64) {
|
||||
// mint coins so that we can add liquidity
|
||||
let account = insecure_pair_from_name("make-pool-account").public();
|
||||
Coins::mint(account, ExternalBalance { coin, amount: Amount(amount) }.into()).unwrap();
|
||||
Coins::mint(account, Balance { coin: Coin::Serai, amount: Amount(amount) }).unwrap();
|
||||
|
||||
// make some liquid pool
|
||||
Dex::add_liquidity(RawOrigin::Signed(account).into(), coin, amount, amount, 1, 1, account)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn validate_batch() {
|
||||
new_test_ext().execute_with(|| {
|
||||
let pair = insecure_pair_from_name("Alice");
|
||||
set_keys_for_session(pair.public());
|
||||
|
||||
let mut batch_size = 0;
|
||||
let mut batch = Batch {
|
||||
network: ExternalNetworkId::Monero,
|
||||
id: 1,
|
||||
external_network_block_hash: BlockHash([0u8; 32]),
|
||||
instructions: vec![],
|
||||
};
|
||||
|
||||
// batch size bigger than MAX_BATCH_SIZE should fail
|
||||
while batch_size <= MAX_BATCH_SIZE + 1000 {
|
||||
batch.instructions.push(InInstructionWithBalance {
|
||||
instruction: InInstruction::Transfer(SeraiAddress::new([0u8; 32])),
|
||||
balance: ExternalBalance { coin: ExternalCoin::Monero, amount: Amount(1) },
|
||||
});
|
||||
batch_size = batch.encode().len();
|
||||
}
|
||||
|
||||
let call = pallet::Call::<Test>::execute_batch {
|
||||
batch: SignedBatch { batch: batch.clone(), signature: Signature([0u8; 64]) },
|
||||
};
|
||||
assert_eq!(
|
||||
InInstructions::validate_unsigned(TransactionSource::External, &call),
|
||||
InvalidTransaction::ExhaustsResources.into()
|
||||
);
|
||||
|
||||
// reduce the batch size into allowed size
|
||||
while batch_size > MAX_BATCH_SIZE {
|
||||
batch.instructions.pop();
|
||||
batch_size = batch.encode().len();
|
||||
}
|
||||
|
||||
// 0 signature should be invalid
|
||||
let call = pallet::Call::<Test>::execute_batch {
|
||||
batch: SignedBatch { batch: batch.clone(), signature: Signature([0u8; 64]) },
|
||||
};
|
||||
assert_eq!(
|
||||
InInstructions::validate_unsigned(TransactionSource::External, &call),
|
||||
InvalidTransaction::BadProof.into()
|
||||
);
|
||||
|
||||
// submit a valid signature
|
||||
let signature = pair.sign(&batch_message(&batch));
|
||||
|
||||
// network shouldn't be halted
|
||||
InInstructions::halt(ExternalNetworkId::Monero).unwrap();
|
||||
let call = pallet::Call::<Test>::execute_batch {
|
||||
batch: SignedBatch { batch: batch.clone(), signature },
|
||||
};
|
||||
assert_eq!(
|
||||
InInstructions::validate_unsigned(TransactionSource::External, &call),
|
||||
InvalidTransaction::Custom(1).into() // network halted error
|
||||
);
|
||||
|
||||
// submit from an un-halted network
|
||||
batch.network = ExternalNetworkId::Bitcoin;
|
||||
let signature = pair.sign(&batch_message(&batch));
|
||||
|
||||
// can't submit in the first block(Block 0)
|
||||
let call = pallet::Call::<Test>::execute_batch {
|
||||
batch: SignedBatch { batch: batch.clone(), signature: signature.clone() },
|
||||
};
|
||||
assert_eq!(
|
||||
InInstructions::validate_unsigned(TransactionSource::External, &call),
|
||||
InvalidTransaction::Future.into()
|
||||
);
|
||||
|
||||
// update block number
|
||||
System::set_block_number(1);
|
||||
|
||||
// first batch id should be 0
|
||||
let call = pallet::Call::<Test>::execute_batch {
|
||||
batch: SignedBatch { batch: batch.clone(), signature: signature.clone() },
|
||||
};
|
||||
assert_eq!(
|
||||
InInstructions::validate_unsigned(TransactionSource::External, &call),
|
||||
InvalidTransaction::Future.into()
|
||||
);
|
||||
|
||||
// update batch id
|
||||
batch.id = 0;
|
||||
let signature = pair.sign(&batch_message(&batch));
|
||||
|
||||
// can't have more than 1 batch per block
|
||||
let call = pallet::Call::<Test>::execute_batch {
|
||||
batch: SignedBatch { batch: batch.clone(), signature: signature.clone() },
|
||||
};
|
||||
assert_eq!(
|
||||
InInstructions::validate_unsigned(TransactionSource::External, &call),
|
||||
InvalidTransaction::Future.into()
|
||||
);
|
||||
|
||||
// update block number
|
||||
System::set_block_number(2);
|
||||
|
||||
// network and the instruction coins should match
|
||||
let call = pallet::Call::<Test>::execute_batch {
|
||||
batch: SignedBatch { batch: batch.clone(), signature },
|
||||
};
|
||||
assert_eq!(
|
||||
InInstructions::validate_unsigned(TransactionSource::External, &call),
|
||||
InvalidTransaction::Custom(2).into() // network and instruction coins doesn't match error
|
||||
);
|
||||
|
||||
// update block number & batch
|
||||
System::set_block_number(3);
|
||||
for ins in &mut batch.instructions {
|
||||
ins.balance.coin = ExternalCoin::Bitcoin;
|
||||
}
|
||||
let signature = pair.sign(&batch_message(&batch));
|
||||
|
||||
// batch id can't be equal or less than previous id
|
||||
let call = pallet::Call::<Test>::execute_batch {
|
||||
batch: SignedBatch { batch: batch.clone(), signature },
|
||||
};
|
||||
assert_eq!(
|
||||
InInstructions::validate_unsigned(TransactionSource::External, &call),
|
||||
InvalidTransaction::Stale.into()
|
||||
);
|
||||
|
||||
// update block number & batch
|
||||
System::set_block_number(4);
|
||||
batch.id += 2;
|
||||
let signature = pair.sign(&batch_message(&batch));
|
||||
|
||||
// batch id can't be incremented more than once per batch
|
||||
let call = pallet::Call::<Test>::execute_batch {
|
||||
batch: SignedBatch { batch: batch.clone(), signature },
|
||||
};
|
||||
assert_eq!(
|
||||
InInstructions::validate_unsigned(TransactionSource::External, &call),
|
||||
InvalidTransaction::Future.into()
|
||||
);
|
||||
|
||||
// update block number & batch
|
||||
System::set_block_number(5);
|
||||
batch.id = (batch.id - 2) + 1;
|
||||
let signature = pair.sign(&batch_message(&batch));
|
||||
|
||||
// it should now pass
|
||||
let call = pallet::Call::<Test>::execute_batch {
|
||||
batch: SignedBatch { batch: batch.clone(), signature },
|
||||
};
|
||||
InInstructions::validate_unsigned(TransactionSource::External, &call).unwrap();
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transfer_instruction() {
|
||||
new_test_ext().execute_with(|| {
|
||||
let coin = ExternalCoin::Bitcoin;
|
||||
let amount = Amount(2 * 10u64.pow(coin.decimals()));
|
||||
let account = insecure_pair_from_name("random1").public();
|
||||
let batch = SignedBatch {
|
||||
batch: Batch {
|
||||
network: coin.network(),
|
||||
id: 0,
|
||||
external_network_block_hash: BlockHash([0u8; 32]),
|
||||
instructions: vec![InInstructionWithBalance {
|
||||
instruction: InInstruction::Transfer(account.into()),
|
||||
balance: ExternalBalance { coin, amount },
|
||||
}],
|
||||
},
|
||||
signature: Signature([0u8; 64]),
|
||||
};
|
||||
InInstructions::execute_batch(RawOrigin::None.into(), batch).unwrap();
|
||||
|
||||
// check that account has the coins
|
||||
assert_eq!(Coins::balance(account, coin.into()), amount);
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dex_instruction_add_liquidity() {
|
||||
new_test_ext().execute_with(|| {
|
||||
let coin = ExternalCoin::Ether;
|
||||
let amount = Amount(2 * 10u64.pow(coin.decimals()));
|
||||
let account = insecure_pair_from_name("random1").public();
|
||||
|
||||
let batch = SignedBatch {
|
||||
batch: Batch {
|
||||
network: coin.network(),
|
||||
id: 0,
|
||||
external_network_block_hash: BlockHash([0u8; 32]),
|
||||
instructions: vec![InInstructionWithBalance {
|
||||
instruction: InInstruction::Dex(DexCall::SwapAndAddLiquidity(account.into())),
|
||||
balance: ExternalBalance { coin, amount },
|
||||
}],
|
||||
},
|
||||
signature: Signature([0u8; 64]),
|
||||
};
|
||||
|
||||
// we should have a liquid pool before we can swap
|
||||
InInstructions::execute_batch(RawOrigin::None.into(), batch.clone()).unwrap();
|
||||
|
||||
// check that the instruction is failed
|
||||
/* TODO
|
||||
assert_eq!(
|
||||
get_events()
|
||||
.into_iter()
|
||||
.filter(|event| matches!(event, in_instructions::Event::<Test>::InstructionFailure { .. }))
|
||||
.collect::<Vec<_>>(),
|
||||
vec![in_instructions::Event::<Test>::InstructionFailure {
|
||||
network: batch.batch.network,
|
||||
id: batch.batch.id,
|
||||
index: 0
|
||||
}]
|
||||
);
|
||||
*/
|
||||
|
||||
let original_coin_amount = 5 * 10u64.pow(coin.decimals());
|
||||
make_liquid_pool(coin, original_coin_amount);
|
||||
|
||||
// this should now be successful
|
||||
InInstructions::execute_batch(RawOrigin::None.into(), batch).unwrap();
|
||||
|
||||
// check that the instruction was successful
|
||||
/* TODO
|
||||
assert_eq!(
|
||||
get_events()
|
||||
.into_iter()
|
||||
.filter(|event| matches!(event, in_instructions::Event::<Test>::InstructionFailure { .. }))
|
||||
.collect::<Vec<_>>(),
|
||||
vec![]
|
||||
);
|
||||
*/
|
||||
|
||||
// check that we now have a Ether pool with correct liquidity
|
||||
// we can't know the actual SRI amount since we don't know the result of the swap.
|
||||
// Moreover, knowing exactly how much isn't the responsibility of InInstruction pallet,
|
||||
// it is responsibility of the Dex pallet.
|
||||
let (coin_amount, _serai_amount) = Dex::get_reserves(&coin.into(), &Coin::Serai).unwrap();
|
||||
assert_eq!(coin_amount, original_coin_amount + amount.0);
|
||||
|
||||
// assert that the account got the liquidity tokens, again we don't how much and
|
||||
// it isn't this pallets responsibility.
|
||||
assert!(LiquidityTokens::balance(account, coin.into()).0 > 0);
|
||||
|
||||
// check that in ins account doesn't have the coins
|
||||
assert_eq!(Coins::balance(IN_INSTRUCTION_EXECUTOR.into(), coin.into()), Amount(0));
|
||||
assert_eq!(Coins::balance(IN_INSTRUCTION_EXECUTOR.into(), Coin::Serai), Amount(0));
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dex_instruction_swap() {
|
||||
new_test_ext().execute_with(|| {
|
||||
let coin = ExternalCoin::Bitcoin;
|
||||
let amount = Amount(2 * 10u64.pow(coin.decimals()));
|
||||
let account = insecure_pair_from_name("random1").public();
|
||||
|
||||
// make a pool so that can actually swap
|
||||
make_liquid_pool(coin, 5 * 10u64.pow(coin.decimals()));
|
||||
|
||||
let mut batch = SignedBatch {
|
||||
batch: Batch {
|
||||
network: coin.network(),
|
||||
id: 0,
|
||||
external_network_block_hash: BlockHash([0u8; 32]),
|
||||
instructions: vec![InInstructionWithBalance {
|
||||
instruction: InInstruction::Dex(DexCall::Swap(
|
||||
Balance { coin: Coin::Serai, amount: Amount(1) },
|
||||
OutAddress::External(ExternalAddress::new([0u8; 64].to_vec()).unwrap()),
|
||||
)),
|
||||
balance: ExternalBalance { coin, amount },
|
||||
}],
|
||||
},
|
||||
signature: Signature([0u8; 64]),
|
||||
};
|
||||
|
||||
// we can't send SRI to external address
|
||||
InInstructions::execute_batch(RawOrigin::None.into(), batch.clone()).unwrap();
|
||||
|
||||
// check that the instruction was failed
|
||||
/* TODO
|
||||
assert_eq!(
|
||||
get_events()
|
||||
.into_iter()
|
||||
.filter(|event| matches!(event, in_instructions::Event::<Test>::InstructionFailure { .. }))
|
||||
.collect::<Vec<_>>(),
|
||||
vec![in_instructions::Event::<Test>::InstructionFailure {
|
||||
network: batch.batch.network,
|
||||
id: batch.batch.id,
|
||||
index: 0
|
||||
}]
|
||||
);
|
||||
*/
|
||||
|
||||
// make it internal address
|
||||
batch.batch.instructions[0].instruction = InInstruction::Dex(DexCall::Swap(
|
||||
Balance { coin: Coin::Serai, amount: Amount(1) },
|
||||
OutAddress::Serai(account.into()),
|
||||
));
|
||||
|
||||
// check that swap is successful this time
|
||||
assert_eq!(Coins::balance(account, Coin::Serai), Amount(0));
|
||||
InInstructions::execute_batch(RawOrigin::None.into(), batch.clone()).unwrap();
|
||||
assert!(Coins::balance(account, Coin::Serai).0 > 0);
|
||||
|
||||
// make another pool for external coin
|
||||
let coin2 = ExternalCoin::Monero;
|
||||
make_liquid_pool(coin2, 5 * 10u64.pow(coin.decimals()));
|
||||
|
||||
// update the batch
|
||||
let out_addr = ExternalAddress::new([0u8; 64].to_vec()).unwrap();
|
||||
batch.batch.instructions[0].instruction = InInstruction::Dex(DexCall::Swap(
|
||||
Balance { coin: ExternalCoin::Monero.into(), amount: Amount(1) },
|
||||
OutAddress::External(out_addr.clone()),
|
||||
));
|
||||
InInstructions::execute_batch(RawOrigin::None.into(), batch.clone()).unwrap();
|
||||
|
||||
// check that we got out instruction
|
||||
let events = System::events()
|
||||
.iter()
|
||||
.filter_map(|event| {
|
||||
if let RuntimeEvent::Coins(e) = &event.event {
|
||||
if matches!(e, coins::Event::<Test>::BurnWithInstruction { .. }) {
|
||||
Some(e.clone())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
assert_eq!(
|
||||
events,
|
||||
vec![coins::Event::<Test>::BurnWithInstruction {
|
||||
from: IN_INSTRUCTION_EXECUTOR.into(),
|
||||
instruction: OutInstructionWithBalance {
|
||||
instruction: OutInstruction { address: out_addr },
|
||||
balance: ExternalBalance { coin: coin2, amount: Amount(68228493) }
|
||||
}
|
||||
}]
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn genesis_liquidity_instruction() {
|
||||
new_test_ext().execute_with(|| {
|
||||
let coin = ExternalCoin::Bitcoin;
|
||||
let amount = Amount(2 * 10u64.pow(coin.decimals()));
|
||||
let account = insecure_pair_from_name("random1").public();
|
||||
|
||||
let batch = SignedBatch {
|
||||
batch: Batch {
|
||||
network: coin.network(),
|
||||
id: 0,
|
||||
external_network_block_hash: BlockHash([0u8; 32]),
|
||||
instructions: vec![InInstructionWithBalance {
|
||||
instruction: InInstruction::GenesisLiquidity(account.into()),
|
||||
balance: ExternalBalance { coin, amount },
|
||||
}],
|
||||
},
|
||||
signature: Signature([0u8; 64]),
|
||||
};
|
||||
|
||||
InInstructions::execute_batch(RawOrigin::None.into(), batch.clone()).unwrap();
|
||||
|
||||
// check that genesis liq account got the coins
|
||||
assert_eq!(Coins::balance(GENESIS_LIQUIDITY_ACCOUNT.into(), coin.into()), amount);
|
||||
|
||||
// check that it registered the liquidity for the account
|
||||
// detailed tests about the amounts has to be done in GenesisLiquidity pallet tests.
|
||||
let liquidity_amount = GenesisLiquidity::liquidity(coin, account).unwrap();
|
||||
assert_eq!(liquidity_amount.coins, amount.0);
|
||||
assert_eq!(liquidity_amount.shares, INITIAL_GENESIS_LP_SHARES);
|
||||
|
||||
let supply = GenesisLiquidity::supply(coin).unwrap();
|
||||
assert_eq!(supply.coins, amount.0);
|
||||
assert_eq!(supply.shares, INITIAL_GENESIS_LP_SHARES);
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn swap_to_staked_sri_instruction() {
|
||||
new_test_ext().execute_with(|| {
|
||||
let coin = ExternalCoin::Monero;
|
||||
let key_share =
|
||||
ValidatorSets::<Test>::allocation_per_key_share(NetworkId::from(coin.network())).unwrap();
|
||||
let amount = Amount(2 * key_share.0);
|
||||
let account = insecure_pair_from_name("random1").public();
|
||||
|
||||
// make a pool so that can actually swap
|
||||
make_liquid_pool(coin, 5 * 10u64.pow(coin.decimals()));
|
||||
|
||||
// set the keys to set the TAS for the network
|
||||
ValidatorSets::<Test>::set_keys(
|
||||
RawOrigin::None.into(),
|
||||
coin.network(),
|
||||
KeyPair(insecure_pair_from_name("random-key").public(), Vec::new().try_into().unwrap()),
|
||||
Vec::new().try_into().unwrap(),
|
||||
Signature([0u8; 64]),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// make sure account doesn't already have lTs or allocation
|
||||
let current_liq_tokens = LiquidityTokens::balance(POL_ACCOUNT.into(), coin.into()).0;
|
||||
assert_eq!(current_liq_tokens, 0);
|
||||
assert_eq!(ValidatorSets::<Test>::allocation((NetworkId::from(coin.network()), account)), None);
|
||||
|
||||
// we need this so that value for the coin exist
|
||||
Dex::on_finalize(0);
|
||||
System::set_block_number(1); // we need this for the spot price
|
||||
|
||||
let batch = SignedBatch {
|
||||
batch: Batch {
|
||||
network: coin.network(),
|
||||
id: 0,
|
||||
external_network_block_hash: BlockHash([0u8; 32]),
|
||||
instructions: vec![InInstructionWithBalance {
|
||||
instruction: InInstruction::SwapToStakedSRI(account.into(), coin.network().into()),
|
||||
balance: ExternalBalance { coin, amount },
|
||||
}],
|
||||
},
|
||||
signature: Signature([0u8; 64]),
|
||||
};
|
||||
|
||||
InInstructions::execute_batch(RawOrigin::None.into(), batch.clone()).unwrap();
|
||||
|
||||
// assert that we added liq from POL account
|
||||
assert!(LiquidityTokens::balance(POL_ACCOUNT.into(), coin.into()).0 > current_liq_tokens);
|
||||
|
||||
// assert that user allocated SRI for the network
|
||||
let value = Dex::spot_price_for_block(0, coin).unwrap();
|
||||
let sri_amount = Amount(
|
||||
u64::try_from(
|
||||
u128::from(amount.0)
|
||||
.checked_mul(u128::from(value.0))
|
||||
.unwrap()
|
||||
.checked_div(u128::from(10u64.pow(coin.decimals())))
|
||||
.unwrap(),
|
||||
)
|
||||
.unwrap(),
|
||||
);
|
||||
assert_eq!(
|
||||
ValidatorSets::<Test>::allocation((NetworkId::from(coin.network()), account)).unwrap(),
|
||||
sri_amount
|
||||
);
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user