e2etests

package
v0.0.0-...-2da98db Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 17, 2024 License: MIT Imports: 46 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	/*
	 ZETA tests
	 Test transfer of ZETA asset across chains
	*/
	TestZetaDepositName           = "zeta_deposit"
	TestZetaDepositNewAddressName = "zeta_deposit_new_address"
	TestZetaDepositRestrictedName = "zeta_deposit_restricted"
	TestZetaWithdrawName          = "zeta_withdraw"
	TestZetaWithdrawBTCRevertName = "zeta_withdraw_btc_revert" // #nosec G101 - not a hardcoded password

	/*
	 Message passing tests
	 Test message passing across chains
	*/
	TestMessagePassingExternalChainsName              = "message_passing_external_chains"
	TestMessagePassingRevertFailExternalChainsName    = "message_passing_revert_fail"
	TestMessagePassingRevertSuccessExternalChainsName = "message_passing_revert_success"
	TestMessagePassingEVMtoZEVMName                   = "message_passing_evm_to_zevm"
	TestMessagePassingZEVMToEVMName                   = "message_passing_zevm_to_evm"
	TestMessagePassingZEVMtoEVMRevertName             = "message_passing_zevm_to_evm_revert"
	TestMessagePassingEVMtoZEVMRevertName             = "message_passing_evm_to_zevm_revert"
	TestMessagePassingZEVMtoEVMRevertFailName         = "message_passing_zevm_to_evm_revert_fail"
	TestMessagePassingEVMtoZEVMRevertFailName         = "message_passing_evm_to_zevm_revert_fail"

	/*
	 EVM gas tests
	 Test transfer of EVM gas asset across chains
	*/
	TestEtherDepositName              = "eth_deposit"
	TestEtherWithdrawName             = "eth_withdraw"
	TestEtherWithdrawRestrictedName   = "eth_withdraw_restricted"
	TestEtherDepositAndCallRefundName = "eth_deposit_and_call_refund"
	TestEtherDepositAndCallName       = "eth_deposit_and_call"

	/*
	 EVM erc20 tests
	 Test transfer of EVM erc20 asset across chains
	*/
	TestERC20WithdrawName             = "erc20_withdraw"
	TestERC20DepositName              = "erc20_deposit"
	TestMultipleERC20DepositName      = "erc20_multiple_deposit"
	TestMultipleERC20WithdrawsName    = "erc20_multiple_withdraw"
	TestERC20DepositRestrictedName    = "erc20_deposit_restricted" // #nosec G101: Potential hardcoded credentials (gosec), not a credential
	TestERC20DepositAndCallRefundName = "erc20_deposit_and_call_refund"

	/*
	 Bitcoin tests
	 Test transfer of Bitcoin asset across chains
	*/
	TestBitcoinDepositName                = "bitcoin_deposit"
	TestBitcoinDepositRefundName          = "bitcoin_deposit_refund"
	TestBitcoinWithdrawSegWitName         = "bitcoin_withdraw_segwit"
	TestBitcoinWithdrawTaprootName        = "bitcoin_withdraw_taproot"
	TestBitcoinWithdrawMultipleName       = "bitcoin_withdraw_multiple"
	TestBitcoinWithdrawLegacyName         = "bitcoin_withdraw_legacy"
	TestBitcoinWithdrawP2WSHName          = "bitcoin_withdraw_p2wsh"
	TestBitcoinWithdrawP2SHName           = "bitcoin_withdraw_p2sh"
	TestBitcoinWithdrawInvalidAddressName = "bitcoin_withdraw_invalid"
	TestBitcoinWithdrawRestrictedName     = "bitcoin_withdraw_restricted"

	/*
	 Application tests
	 Test various smart contract applications across chains
	*/
	TestZRC20SwapName      = "zrc20_swap"
	TestCrosschainSwapName = "crosschain_swap"

	/*
	 Miscellaneous tests
	 Test various functionalities not related to assets
	*/
	TestContextUpgradeName = "context_upgrade"
	TestMyTestName         = "my_test"
	TestDonationEtherName  = "donation_ether"

	/*
	 Stress tests
	 Test stressing networks with many cross-chain transactions
	*/
	TestStressEtherWithdrawName = "stress_eth_withdraw"
	TestStressBTCWithdrawName   = "stress_btc_withdraw"
	TestStressEtherDepositName  = "stress_eth_deposit"
	TestStressBTCDepositName    = "stress_btc_deposit"

	/*
	 Admin tests
	 Test admin functionalities
	*/
	TestDepositEtherLiquidityCapName = "deposit_eth_liquidity_cap"
	TestMigrateChainSupportName      = "migrate_chain_support"
	TestPauseZRC20Name               = "pause_zrc20"
	TestUpdateBytecodeZRC20Name      = "update_bytecode_zrc20"
	TestUpdateBytecodeConnectorName  = "update_bytecode_connector"
	TestRateLimiterName              = "rate_limiter"

	TestMigrateTSSName = "migrate_TSS"

	/*
	 Special tests
	 Not used to test functionalities but do various interactions with the netwoks
	*/
	TestDeploy = "deploy"
)

List of all e2e test names to be used in zetae2e

View Source 
const EVM2RPCURL = "http://eth2:8545"

EVM2RPCURL is the RPC URL for the additional EVM localnet Only this test currently uses a additional EVM localnet, and this test is only run locally Therefore, we hardcode RPC urls and addresses for simplicity

Variables

View Source 
var AllE2ETests = []runner.E2ETest{

	runner.NewE2ETest(
		TestZetaDepositName,
		"deposit ZETA from Ethereum to ZEVM",
		[]runner.ArgDefinition{
			{Description: "amount in azeta", DefaultValue: "1000000000000000000"},
		},
		TestZetaDeposit,
	),
	runner.NewE2ETest(
		TestZetaDepositNewAddressName,
		"deposit ZETA from Ethereum to a new ZEVM address which does not exist yet",
		[]runner.ArgDefinition{
			{Description: "amount in azeta", DefaultValue: "1000000000000000000"},
		},
		TestZetaDepositNewAddress,
	),
	runner.NewE2ETest(
		TestZetaDepositRestrictedName,
		"deposit ZETA from Ethereum to ZEVM restricted address",
		[]runner.ArgDefinition{
			{Description: "amount in azeta", DefaultValue: "1000000000000000000"},
		},
		TestZetaDepositRestricted,
	),
	runner.NewE2ETest(
		TestZetaWithdrawName,
		"withdraw ZETA from ZEVM to Ethereum",
		[]runner.ArgDefinition{
			{Description: "amount in azeta", DefaultValue: "10000000000000000000"},
		},
		TestZetaWithdraw,
	),
	runner.NewE2ETest(
		TestZetaWithdrawBTCRevertName,
		"sending ZETA from ZEVM to Bitcoin with a message that should revert cctxs",
		[]runner.ArgDefinition{
			{Description: "amount in azeta", DefaultValue: "1000000000000000000"},
		},
		TestZetaWithdrawBTCRevert,
	),

	runner.NewE2ETest(
		TestMessagePassingExternalChainsName,
		"evm->evm message passing (sending ZETA only)",
		[]runner.ArgDefinition{
			{Description: "amount in azeta", DefaultValue: "10000000000000000000"},
		},
		TestMessagePassingExternalChains,
	),
	runner.NewE2ETest(
		TestMessagePassingRevertFailExternalChainsName,
		"message passing with failing revert between external EVM chains",
		[]runner.ArgDefinition{
			{Description: "amount in azeta", DefaultValue: "10000000000000000000"},
		},
		TestMessagePassingRevertFailExternalChains,
	),
	runner.NewE2ETest(
		TestMessagePassingRevertSuccessExternalChainsName,
		"message passing with successful revert between external EVM chains",
		[]runner.ArgDefinition{
			{Description: "amount in azeta", DefaultValue: "10000000000000000000"},
		},
		TestMessagePassingRevertSuccessExternalChains,
	),
	runner.NewE2ETest(
		TestMessagePassingEVMtoZEVMName,
		"evm -> zevm message passing contract call ",
		[]runner.ArgDefinition{
			{Description: "amount in azeta", DefaultValue: "10000000000000000009"},
		},
		TestMessagePassingEVMtoZEVM,
	),
	runner.NewE2ETest(
		TestMessagePassingZEVMToEVMName,
		"zevm -> evm message passing contract call",
		[]runner.ArgDefinition{
			{Description: "amount in azeta", DefaultValue: "10000000000000000007"},
		},
		TestMessagePassingZEVMtoEVM,
	),
	runner.NewE2ETest(
		TestMessagePassingZEVMtoEVMRevertName,
		"zevm -> evm message passing contract call reverts",
		[]runner.ArgDefinition{
			{Description: "amount in azeta", DefaultValue: "10000000000000000006"},
		},
		TestMessagePassingZEVMtoEVMRevert,
	),
	runner.NewE2ETest(
		TestMessagePassingEVMtoZEVMRevertName,
		"evm -> zevm message passing and revert back to evm",
		[]runner.ArgDefinition{
			{Description: "amount in azeta", DefaultValue: "10000000000000000008"},
		},
		TestMessagePassingEVMtoZEVMRevert,
	),
	runner.NewE2ETest(
		TestMessagePassingZEVMtoEVMRevertFailName,
		"zevm -> evm message passing contract with failing revert",
		[]runner.ArgDefinition{
			{Description: "amount in azeta", DefaultValue: "10000000000000000008"},
		},
		TestMessagePassingZEVMtoEVMRevertFail,
	),
	runner.NewE2ETest(
		TestMessagePassingEVMtoZEVMRevertFailName,
		"evm -> zevm message passing contract with failing revert",
		[]runner.ArgDefinition{
			{Description: "amount in azeta", DefaultValue: "10000000000000000008"},
		},
		TestMessagePassingEVMtoZEVMRevertFail,
	),

	runner.NewE2ETest(
		TestEtherDepositName,
		"deposit Ether into ZEVM",
		[]runner.ArgDefinition{
			{Description: "amount in wei", DefaultValue: "10000000000000000"},
		},
		TestEtherDeposit,
	),
	runner.NewE2ETest(
		TestEtherWithdrawName,
		"withdraw Ether from ZEVM",
		[]runner.ArgDefinition{
			{Description: "amount in wei", DefaultValue: "100000"},
		},
		TestEtherWithdraw,
	),
	runner.NewE2ETest(
		TestEtherWithdrawRestrictedName,
		"withdraw Ether from ZEVM to restricted address",
		[]runner.ArgDefinition{
			{Description: "amount in wei", DefaultValue: "100000"},
		},
		TestEtherWithdrawRestricted,
	),
	runner.NewE2ETest(
		TestEtherDepositAndCallRefundName,
		"deposit Ether into ZEVM and call a contract that reverts; should refund",
		[]runner.ArgDefinition{
			{Description: "amount in wei", DefaultValue: "10000000000000000000"},
		},
		TestEtherDepositAndCallRefund,
	),
	runner.NewE2ETest(
		TestEtherDepositAndCallName,
		"deposit ZRC20 into ZEVM and call a contract",
		[]runner.ArgDefinition{
			{Description: "amount in wei", DefaultValue: "1000000000000000000"},
		},
		TestEtherDepositAndCall,
	),

	runner.NewE2ETest(
		TestERC20WithdrawName,
		"withdraw ERC20 from ZEVM",
		[]runner.ArgDefinition{
			{Description: "amount", DefaultValue: "1000"},
		},
		TestERC20Withdraw,
	),
	runner.NewE2ETest(
		TestERC20DepositName,
		"deposit ERC20 into ZEVM",
		[]runner.ArgDefinition{
			{Description: "amount", DefaultValue: "100000"},
		},
		TestERC20Deposit,
	),
	runner.NewE2ETest(
		TestMultipleERC20DepositName,
		"deposit ERC20 into ZEVM in multiple deposits",
		[]runner.ArgDefinition{
			{Description: "amount", DefaultValue: "1000000000"},
			{Description: "count", DefaultValue: "3"},
		},
		TestMultipleERC20Deposit,
	),
	runner.NewE2ETest(
		TestMultipleERC20WithdrawsName,
		"withdraw ERC20 from ZEVM in multiple withdrawals",
		[]runner.ArgDefinition{
			{Description: "amount", DefaultValue: "100"},
			{Description: "count", DefaultValue: "3"},
		},
		TestMultipleERC20Withdraws,
	),
	runner.NewE2ETest(
		TestERC20DepositRestrictedName,
		"deposit ERC20 into ZEVM restricted address",
		[]runner.ArgDefinition{
			{Description: "amount", DefaultValue: "100000"},
		},
		TestERC20DepositRestricted,
	),
	runner.NewE2ETest(
		TestERC20DepositAndCallRefundName,
		"deposit a non-gas ZRC20 into ZEVM and call a contract that reverts",
		[]runner.ArgDefinition{},
		TestERC20DepositAndCallRefund,
	),

	runner.NewE2ETest(
		TestBitcoinDepositName,
		"deposit Bitcoin into ZEVM",
		[]runner.ArgDefinition{
			{Description: "amount in btc", DefaultValue: "0.001"},
		},
		TestBitcoinDeposit,
	),
	runner.NewE2ETest(
		TestBitcoinDepositRefundName,
		"deposit Bitcoin into ZEVM; expect refund", []runner.ArgDefinition{
			{Description: "amount in btc", DefaultValue: "0.1"},
		},
		TestBitcoinDepositRefund,
	),
	runner.NewE2ETest(
		TestBitcoinWithdrawSegWitName,
		"withdraw BTC from ZEVM to a SegWit address",
		[]runner.ArgDefinition{
			{Description: "receiver address", DefaultValue: ""},
			{Description: "amount in btc", DefaultValue: "0.001"},
		},
		TestBitcoinWithdrawSegWit,
	),
	runner.NewE2ETest(
		TestBitcoinWithdrawTaprootName,
		"withdraw BTC from ZEVM to a Taproot address",
		[]runner.ArgDefinition{
			{Description: "receiver address", DefaultValue: ""},
			{Description: "amount in btc", DefaultValue: "0.001"},
		},
		TestBitcoinWithdrawTaproot,
	),
	runner.NewE2ETest(
		TestBitcoinWithdrawLegacyName,
		"withdraw BTC from ZEVM to a legacy address",
		[]runner.ArgDefinition{
			{Description: "receiver address", DefaultValue: ""},
			{Description: "amount in btc", DefaultValue: "0.001"},
		},
		TestBitcoinWithdrawLegacy,
	),
	runner.NewE2ETest(
		TestBitcoinWithdrawMultipleName,
		"withdraw BTC from ZEVM multiple times",
		[]runner.ArgDefinition{
			{Description: "amount", DefaultValue: "0.01"},
			{Description: "times", DefaultValue: "2"},
		},
		WithdrawBitcoinMultipleTimes,
	),
	runner.NewE2ETest(
		TestBitcoinWithdrawP2WSHName,
		"withdraw BTC from ZEVM to a P2WSH address",
		[]runner.ArgDefinition{
			{Description: "receiver address", DefaultValue: ""},
			{Description: "amount in btc", DefaultValue: "0.001"},
		},
		TestBitcoinWithdrawP2WSH,
	),
	runner.NewE2ETest(
		TestBitcoinWithdrawP2SHName,
		"withdraw BTC from ZEVM to a P2SH address",
		[]runner.ArgDefinition{
			{Description: "receiver address", DefaultValue: ""},
			{Description: "amount in btc", DefaultValue: "0.001"},
		},
		TestBitcoinWithdrawP2SH,
	),
	runner.NewE2ETest(
		TestBitcoinWithdrawInvalidAddressName,
		"withdraw BTC from ZEVM to an unsupported btc address",
		[]runner.ArgDefinition{
			{Description: "amount in btc", DefaultValue: "0.00001"},
		},
		TestBitcoinWithdrawToInvalidAddress,
	),
	runner.NewE2ETest(
		TestBitcoinWithdrawRestrictedName,
		"withdraw Bitcoin from ZEVM to restricted address",
		[]runner.ArgDefinition{
			{Description: "amount in btc", DefaultValue: "0.001"},
		},
		TestBitcoinWithdrawRestricted,
	),

	runner.NewE2ETest(
		TestZRC20SwapName,
		"swap ZRC20 ERC20 for ZRC20 ETH",
		[]runner.ArgDefinition{},
		TestZRC20Swap,
	),
	runner.NewE2ETest(
		TestCrosschainSwapName,
		"testing Bitcoin ERC20 cross-chain swap",
		[]runner.ArgDefinition{},
		TestCrosschainSwap,
	),

	runner.NewE2ETest(
		TestContextUpgradeName,
		"tests sending ETH on ZEVM and check context data using ContextApp",
		[]runner.ArgDefinition{
			{Description: "amount in wei", DefaultValue: "1000000000000000"},
		},
		TestContextUpgrade,
	),
	runner.NewE2ETest(
		TestMyTestName,
		"performing custom test",
		[]runner.ArgDefinition{},
		TestMyTest,
	),
	runner.NewE2ETest(
		TestDonationEtherName,
		"donate Ether to the TSS",
		[]runner.ArgDefinition{
			{Description: "amount in wei", DefaultValue: "100000000000000000"},
		},
		TestDonationEther,
	),

	runner.NewE2ETest(
		TestStressEtherWithdrawName,
		"stress test Ether withdrawal",
		[]runner.ArgDefinition{
			{Description: "amount in wei", DefaultValue: "100000"},
			{Description: "count", DefaultValue: "100"},
		},
		TestStressEtherWithdraw,
	),
	runner.NewE2ETest(
		TestStressBTCWithdrawName,
		"stress test BTC withdrawal",
		[]runner.ArgDefinition{
			{Description: "amount in btc", DefaultValue: "0.01"},
			{Description: "count", DefaultValue: "100"},
		},
		TestStressBTCWithdraw,
	),
	runner.NewE2ETest(
		TestStressEtherDepositName,
		"stress test Ether deposit",
		[]runner.ArgDefinition{
			{Description: "amount in wei", DefaultValue: "100000"},
			{Description: "count", DefaultValue: "100"},
		},
		TestStressEtherDeposit,
	),
	runner.NewE2ETest(
		TestStressBTCDepositName,
		"stress test BTC deposit",
		[]runner.ArgDefinition{
			{Description: "amount in btc", DefaultValue: "0.001"},
			{Description: "count", DefaultValue: "100"},
		},
		TestStressBTCDeposit,
	),

	runner.NewE2ETest(
		TestDepositEtherLiquidityCapName,
		"deposit Ethers into ZEVM with a liquidity cap",
		[]runner.ArgDefinition{
			{Description: "amount in wei", DefaultValue: "100000000000000"},
		},
		TestDepositEtherLiquidityCap,
	),
	runner.NewE2ETest(
		TestMigrateChainSupportName,
		"migrate the evm chain from goerli to sepolia",
		[]runner.ArgDefinition{},
		TestMigrateChainSupport,
	),
	runner.NewE2ETest(
		TestPauseZRC20Name,
		"pausing ZRC20 on ZetaChain",
		[]runner.ArgDefinition{},
		TestPauseZRC20,
	),
	runner.NewE2ETest(
		TestUpdateBytecodeZRC20Name,
		"update ZRC20 bytecode swap",
		[]runner.ArgDefinition{},
		TestUpdateBytecodeZRC20,
	),
	runner.NewE2ETest(
		TestUpdateBytecodeConnectorName,
		"update zevm connector bytecode",
		[]runner.ArgDefinition{},
		TestUpdateBytecodeConnector,
	),
	runner.NewE2ETest(
		TestRateLimiterName,
		"test sending cctxs with rate limiter enabled and show logs when processing cctxs",
		[]runner.ArgDefinition{},
		TestRateLimiter,
	),

	runner.NewE2ETest(
		TestDeploy,
		"deploy a contract",
		[]runner.ArgDefinition{
			{Description: "contract name", DefaultValue: ""},
		},
		TestDeployContract,
	),
	runner.NewE2ETest(
		TestMigrateTSSName,
		"migrate TSS funds",
		[]runner.ArgDefinition{},
		TestMigrateTSS,
	),
}

AllE2ETests is an ordered list of all e2e tests

View Source 
var EVMSepoliaChainID = chains.Sepolia.ChainId

EVMSepoliaChainID is the chain ID for the additional EVM localnet We set Sepolia testnet although the value is not important, only used to differentiate

Functions

func TestBitcoinDeposit 

func TestBitcoinDeposit(r *runner.E2ERunner, args []string)

func TestBitcoinDepositRefund 

func TestBitcoinDepositRefund(r *runner.E2ERunner, args []string)

func TestBitcoinWithdrawLegacy 

func TestBitcoinWithdrawLegacy(r *runner.E2ERunner, args []string)

func TestBitcoinWithdrawP2SH 

func TestBitcoinWithdrawP2SH(r *runner.E2ERunner, args []string)

func TestBitcoinWithdrawP2WSH 

func TestBitcoinWithdrawP2WSH(r *runner.E2ERunner, args []string)

func TestBitcoinWithdrawRestricted 

func TestBitcoinWithdrawRestricted(r *runner.E2ERunner, args []string)

func TestBitcoinWithdrawSegWit 

func TestBitcoinWithdrawSegWit(r *runner.E2ERunner, args []string)

func TestBitcoinWithdrawTaproot 

func TestBitcoinWithdrawTaproot(r *runner.E2ERunner, args []string)

func TestBitcoinWithdrawToInvalidAddress 

func TestBitcoinWithdrawToInvalidAddress(r *runner.E2ERunner, args []string)

func TestContextUpgrade 

func TestContextUpgrade(r *runner.E2ERunner, args []string)

TestContextUpgrade tests sending ETH on ZetaChain and check context data

func TestCrosschainSwap 

func TestCrosschainSwap(r *runner.E2ERunner, _ []string)

func TestDeployContract 

func TestDeployContract(r *runner.E2ERunner, args []string)

TestDeployContract deploys the specified contract

func TestDepositEtherLiquidityCap 

func TestDepositEtherLiquidityCap(r *runner.E2ERunner, args []string)

TestDepositEtherLiquidityCap tests depositing Ethers in a context where a liquidity cap is set

func TestDonationEther 

func TestDonationEther(r *runner.E2ERunner, args []string)

TestDonationEther tests donation of ether to the tss address

func TestERC20Deposit 

func TestERC20Deposit(r *runner.E2ERunner, args []string)

func TestERC20DepositAndCallRefund 

func TestERC20DepositAndCallRefund(r *runner.E2ERunner, _ []string)

func TestERC20DepositRestricted 

func TestERC20DepositRestricted(r *runner.E2ERunner, args []string)

func TestERC20Withdraw 

func TestERC20Withdraw(r *runner.E2ERunner, args []string)

func TestEtherDeposit 

func TestEtherDeposit(r *runner.E2ERunner, args []string)

TestEtherDeposit tests deposit of ethers

func TestEtherDepositAndCall 

func TestEtherDepositAndCall(r *runner.E2ERunner, args []string)

TestEtherDepositAndCall tests deposit of ethers calling a example contract

func TestEtherDepositAndCallRefund 

func TestEtherDepositAndCallRefund(r *runner.E2ERunner, args []string)

func TestEtherWithdraw 

func TestEtherWithdraw(r *runner.E2ERunner, args []string)

TestEtherWithdraw tests the withdrawal of ether

func TestEtherWithdrawRestricted 

func TestEtherWithdrawRestricted(r *runner.E2ERunner, args []string)

TestEtherWithdrawRestricted tests the withdrawal to a restricted receiver address

func TestMessagePassingEVMtoZEVM 

func TestMessagePassingEVMtoZEVM(r *runner.E2ERunner, args []string)

func TestMessagePassingEVMtoZEVMRevert 

func TestMessagePassingEVMtoZEVMRevert(r *runner.E2ERunner, args []string)

func TestMessagePassingEVMtoZEVMRevertFail 

func TestMessagePassingEVMtoZEVMRevertFail(r *runner.E2ERunner, args []string)

func TestMessagePassingExternalChains 

func TestMessagePassingExternalChains(r *runner.E2ERunner, args []string)

TestMessagePassingExternalChains tests message passing between external EVM chains TODO: Use two external EVM chains for these tests https://github.com/zeta-chain/node/issues/2185

func TestMessagePassingRevertFailExternalChains 

func TestMessagePassingRevertFailExternalChains(r *runner.E2ERunner, args []string)

TestMessagePassingRevertFailExternalChains tests message passing with failing revert between external EVM chains TODO: Use two external EVM chains for these tests https://github.com/zeta-chain/node/issues/2185

func TestMessagePassingRevertSuccessExternalChains 

func TestMessagePassingRevertSuccessExternalChains(r *runner.E2ERunner, args []string)

TestMessagePassingRevertSuccessExternalChains tests message passing with successful revert between external EVM chains TODO: Use two external EVM chains for these tests https://github.com/zeta-chain/node/issues/2185

func TestMessagePassingZEVMtoEVM 

func TestMessagePassingZEVMtoEVM(r *runner.E2ERunner, args []string)

func TestMessagePassingZEVMtoEVMRevert 

func TestMessagePassingZEVMtoEVMRevert(r *runner.E2ERunner, args []string)

func TestMessagePassingZEVMtoEVMRevertFail 

func TestMessagePassingZEVMtoEVMRevertFail(r *runner.E2ERunner, args []string)

func TestMigrateChainSupport 

func TestMigrateChainSupport(r *runner.E2ERunner, _ []string)

func TestMigrateTSS 

func TestMigrateTSS(r *runner.E2ERunner, _ []string)

func TestMultipleERC20Deposit 

func TestMultipleERC20Deposit(r *runner.E2ERunner, args []string)

func TestMultipleERC20Withdraws 

func TestMultipleERC20Withdraws(r *runner.E2ERunner, args []string)

func TestMyTest 

func TestMyTest(_ *runner.E2ERunner, _ []string)

func TestPauseZRC20 

func TestPauseZRC20(r *runner.E2ERunner, _ []string)

func TestRateLimiter 

func TestRateLimiter(r *runner.E2ERunner, _ []string)

func TestStressBTCDeposit 

func TestStressBTCDeposit(r *runner.E2ERunner, args []string)

TestStressBTCDeposit tests the stressing deposit of BTC

func TestStressBTCWithdraw 

func TestStressBTCWithdraw(r *runner.E2ERunner, args []string)

TestStressBTCWithdraw tests the stressing withdraw of btc

func TestStressEtherDeposit 

func TestStressEtherDeposit(r *runner.E2ERunner, args []string)

TestStressEtherDeposit tests the stressing deposit of ether

func TestStressEtherWithdraw 

func TestStressEtherWithdraw(r *runner.E2ERunner, args []string)

TestStressEtherWithdraw tests the stressing withdraw of ether

func TestUpdateBytecodeConnector 

func TestUpdateBytecodeConnector(r *runner.E2ERunner, _ []string)

TestUpdateBytecodeConnector tests updating the bytecode of a connector and interact with it

func TestUpdateBytecodeZRC20 

func TestUpdateBytecodeZRC20(r *runner.E2ERunner, _ []string)

TestUpdateBytecodeZRC20 tests updating the bytecode of a zrc20 and interact with it

func TestZRC20Swap 

func TestZRC20Swap(r *runner.E2ERunner, _ []string)

func TestZetaDeposit 

func TestZetaDeposit(r *runner.E2ERunner, args []string)

func TestZetaDepositNewAddress 

func TestZetaDepositNewAddress(r *runner.E2ERunner, args []string)

func TestZetaDepositRestricted 

func TestZetaDepositRestricted(r *runner.E2ERunner, args []string)

func TestZetaWithdraw 

func TestZetaWithdraw(r *runner.E2ERunner, args []string)

func TestZetaWithdrawBTCRevert 

func TestZetaWithdrawBTCRevert(r *runner.E2ERunner, args []string)

func WithdrawBitcoinMultipleTimes 

func WithdrawBitcoinMultipleTimes(r *runner.E2ERunner, args []string)

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.