diff --git a/contracts/src/v0.8/ccip/test/helpers/receivers/MaybeRevertMessageReceiver.sol b/contracts/src/v0.8/ccip/test/helpers/receivers/MaybeRevertMessageReceiver.sol index 091c628f09..f1d290338a 100644 --- a/contracts/src/v0.8/ccip/test/helpers/receivers/MaybeRevertMessageReceiver.sol +++ b/contracts/src/v0.8/ccip/test/helpers/receivers/MaybeRevertMessageReceiver.sol @@ -3,55 +3,70 @@ pragma solidity 0.8.24; import {IAny2EVMMessageReceiver} from "../../../interfaces/IAny2EVMMessageReceiver.sol"; import {Client} from "../../../libraries/Client.sol"; - import {IERC165} from "../../../../vendor/openzeppelin-solidity/v5.0.2/contracts/utils/introspection/IERC165.sol"; +import {IERC20} from "../../../../vendor/openzeppelin-solidity/v5.0.2/contracts/token/ERC20/IERC20.sol"; contract MaybeRevertMessageReceiver is IAny2EVMMessageReceiver, IERC165 { error ReceiveRevert(); error CustomError(bytes err); + error Unauthorized(); + error InsufficientBalance(uint256 available, uint256 required); + error TransferFailed(); event ValueReceived(uint256 amount); - event MessageReceived(); + event FundsWithdrawn(address indexed owner, uint256 amount); + event TokensWithdrawn(address indexed token, address indexed owner, uint256 amount); + event MessageReceived( + bytes32 messageId, + uint64 sourceChainSelector, + bytes sender, + bytes data, + Client.EVMTokenAmount[] destTokenAmounts + ); - address private s_manager; + address private immutable s_manager; bool public s_toRevert; bytes private s_err; - constructor( - bool toRevert - ) { + constructor(bool toRevert) { s_manager = msg.sender; s_toRevert = toRevert; } - function setRevert( - bool toRevert - ) external { + modifier onlyManager() { + if (msg.sender != s_manager) { + revert Unauthorized(); + } + _; + } + + function setRevert(bool toRevert) external onlyManager { s_toRevert = toRevert; } - function setErr( - bytes memory err - ) external { + function setErr(bytes memory err) external onlyManager { s_err = err; } /// @notice IERC165 supports an interfaceId /// @param interfaceId The interfaceId to check /// @return true if the interfaceId is supported - function supportsInterface( - bytes4 interfaceId - ) public pure override returns (bool) { + function supportsInterface(bytes4 interfaceId) public pure override returns (bool) { return interfaceId == type(IAny2EVMMessageReceiver).interfaceId || interfaceId == type(IERC165).interfaceId; } - function ccipReceive( - Client.Any2EVMMessage calldata - ) external override { + function ccipReceive(Client.Any2EVMMessage calldata message) external override { if (s_toRevert) { revert CustomError(s_err); } - emit MessageReceived(); + + emit MessageReceived( + message.messageId, + message.sourceChainSelector, + message.sender, + message.data, + message.destTokenAmounts + ); } receive() external payable { @@ -61,4 +76,45 @@ contract MaybeRevertMessageReceiver is IAny2EVMMessageReceiver, IERC165 { emit ValueReceived(msg.value); } + + /// @notice Allows the manager (deployer) to withdraw all Ether from the contract + function withdrawFunds() external onlyManager { + uint256 balance = address(this).balance; + if (balance == 0) { + revert InsufficientBalance(0, 1); + } + + (bool success, ) = s_manager.call{value: balance}(""); + if (!success) { + revert TransferFailed(); + } + + emit FundsWithdrawn(s_manager, balance); + } + + /// @notice Allows the manager to withdraw ERC-20 tokens from the contract + /// @param token The address of the ERC-20 token contract + /// @param amount The amount of tokens to withdraw + function withdrawTokens(address token, uint256 amount) external onlyManager { + IERC20 erc20 = IERC20(token); + uint256 balance = erc20.balanceOf(address(this)); + if (balance < amount) { + revert InsufficientBalance(balance, amount); + } + + bool success = erc20.transfer(s_manager, amount); + if (!success) { + revert TransferFailed(); + } + + emit TokensWithdrawn(token, s_manager, amount); + } + + /// @notice Fetches the balance of an ERC-20 token held by the contract + /// @param token The address of the ERC-20 token contract + /// @return The balance of the specified ERC-20 token + function balanceOfToken(address token) external view returns (uint256) { + IERC20 erc20 = IERC20(token); + return erc20.balanceOf(address(this)); + } } diff --git a/core/gethwrappers/ccip/generated/maybe_revert_message_receiver/maybe_revert_message_receiver.go b/core/gethwrappers/ccip/generated/maybe_revert_message_receiver/maybe_revert_message_receiver.go index 3b52e8c871..f2ddf77353 100644 --- a/core/gethwrappers/ccip/generated/maybe_revert_message_receiver/maybe_revert_message_receiver.go +++ b/core/gethwrappers/ccip/generated/maybe_revert_message_receiver/maybe_revert_message_receiver.go @@ -44,8 +44,8 @@ type ClientEVMTokenAmount struct { } var MaybeRevertMessageReceiverMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"toRevert\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"err\",\"type\":\"bytes\"}],\"name\":\"CustomError\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReceiveRevert\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"MessageReceived\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"ValueReceived\",\"type\":\"event\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"messageId\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"sourceChainSelector\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"sender\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"internalType\":\"structClient.EVMTokenAmount[]\",\"name\":\"destTokenAmounts\",\"type\":\"tuple[]\"}],\"internalType\":\"structClient.Any2EVMMessage\",\"name\":\"\",\"type\":\"tuple\"}],\"name\":\"ccipReceive\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"s_toRevert\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"err\",\"type\":\"bytes\"}],\"name\":\"setErr\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"toRevert\",\"type\":\"bool\"}],\"name\":\"setRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}]", - Bin: "0x608060405234801561001057600080fd5b506040516107e73803806107e783398101604081905261002f9161005d565b600080546001600160a81b0319163360ff60a01b191617600160a01b92151592909202919091179055610086565b60006020828403121561006f57600080fd5b8151801515811461007f57600080fd5b9392505050565b610752806100956000396000f3fe60806040526004361061005e5760003560e01c806377f5b0e61161004357806377f5b0e61461015857806385572ffb1461017a5780638fb5f1711461019a57600080fd5b806301ffc9a7146100f25780635100fc211461012657600080fd5b366100ed5760005474010000000000000000000000000000000000000000900460ff16156100b8576040517f3085b8db00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040513481527fe12e3b7047ff60a2dd763cf536a43597e5ce7fe7aa7476345bd4cd079912bcef9060200160405180910390a1005b600080fd5b3480156100fe57600080fd5b5061011261010d366004610335565b6101ff565b604051901515815260200160405180910390f35b34801561013257600080fd5b506000546101129074010000000000000000000000000000000000000000900460ff1681565b34801561016457600080fd5b506101786101733660046103ad565b610298565b005b34801561018657600080fd5b5061017861019536600461047c565b6102a8565b3480156101a657600080fd5b506101786101b53660046104b7565b6000805491151574010000000000000000000000000000000000000000027fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff909216919091179055565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f85572ffb00000000000000000000000000000000000000000000000000000000148061029257507fffffffff0000000000000000000000000000000000000000000000000000000082167f01ffc9a700000000000000000000000000000000000000000000000000000000145b92915050565b60016102a4828261057d565b5050565b60005474010000000000000000000000000000000000000000900460ff16156103095760016040517f5a4ff6710000000000000000000000000000000000000000000000000000000081526004016103009190610697565b60405180910390fd5b6040517fd82ce31e3523f6eeb2d24317b2b4133001e8472729657f663b68624c45f8f3e890600090a150565b60006020828403121561034757600080fd5b81357fffffffff000000000000000000000000000000000000000000000000000000008116811461037757600080fd5b9392505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6000602082840312156103bf57600080fd5b813567ffffffffffffffff808211156103d757600080fd5b818401915084601f8301126103eb57600080fd5b8135818111156103fd576103fd61037e565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f011681019083821181831017156104435761044361037e565b8160405282815287602084870101111561045c57600080fd5b826020860160208301376000928101602001929092525095945050505050565b60006020828403121561048e57600080fd5b813567ffffffffffffffff8111156104a557600080fd5b820160a0818503121561037757600080fd5b6000602082840312156104c957600080fd5b8135801515811461037757600080fd5b600181811c908216806104ed57607f821691505b602082108103610526577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b50919050565b601f821115610578576000816000526020600020601f850160051c810160208610156105555750805b601f850160051c820191505b8181101561057457828155600101610561565b5050505b505050565b815167ffffffffffffffff8111156105975761059761037e565b6105ab816105a584546104d9565b8461052c565b602080601f8311600181146105fe57600084156105c85750858301515b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600386901b1c1916600185901b178555610574565b6000858152602081207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08616915b8281101561064b5788860151825594840194600190910190840161062c565b508582101561068757878501517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600388901b60f8161c191681555b5050505050600190811b01905550565b60006020808352600084546106ab816104d9565b80602087015260406001808416600081146106cd576001811461070757610737565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00851660408a0152604084151560051b8a01019550610737565b89600052602060002060005b8581101561072e5781548b8201860152908301908801610713565b8a016040019650505b50939897505050505050505056fea164736f6c6343000818000a", + ABI: "[{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"toRevert\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"err\",\"type\":\"bytes\"}],\"name\":\"CustomError\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"available\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"required\",\"type\":\"uint256\"}],\"name\":\"InsufficientBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReceiveRevert\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"FundsWithdrawn\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"messageId\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"sourceChainSelector\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"sender\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"structClient.EVMTokenAmount[]\",\"name\":\"destTokenAmounts\",\"type\":\"tuple[]\"}],\"name\":\"MessageReceived\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"TokensWithdrawn\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"ValueReceived\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"balanceOfToken\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"messageId\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"sourceChainSelector\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"sender\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"internalType\":\"structClient.EVMTokenAmount[]\",\"name\":\"destTokenAmounts\",\"type\":\"tuple[]\"}],\"internalType\":\"structClient.Any2EVMMessage\",\"name\":\"message\",\"type\":\"tuple\"}],\"name\":\"ccipReceive\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"s_toRevert\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"err\",\"type\":\"bytes\"}],\"name\":\"setErr\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"toRevert\",\"type\":\"bool\"}],\"name\":\"setRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawFunds\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdrawTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}]", + Bin: "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", } var MaybeRevertMessageReceiverABI = MaybeRevertMessageReceiverMetaData.ABI @@ -184,6 +184,28 @@ func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverTransactorRaw) Tran return _MaybeRevertMessageReceiver.Contract.contract.Transact(opts, method, params...) } +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverCaller) BalanceOfToken(opts *bind.CallOpts, token common.Address) (*big.Int, error) { + var out []interface{} + err := _MaybeRevertMessageReceiver.contract.Call(opts, &out, "balanceOfToken", token) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverSession) BalanceOfToken(token common.Address) (*big.Int, error) { + return _MaybeRevertMessageReceiver.Contract.BalanceOfToken(&_MaybeRevertMessageReceiver.CallOpts, token) +} + +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverCallerSession) BalanceOfToken(token common.Address) (*big.Int, error) { + return _MaybeRevertMessageReceiver.Contract.BalanceOfToken(&_MaybeRevertMessageReceiver.CallOpts, token) +} + func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverCaller) SToRevert(opts *bind.CallOpts) (bool, error) { var out []interface{} err := _MaybeRevertMessageReceiver.contract.Call(opts, &out, "s_toRevert") @@ -228,16 +250,16 @@ func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverCallerSession) Supp return _MaybeRevertMessageReceiver.Contract.SupportsInterface(&_MaybeRevertMessageReceiver.CallOpts, interfaceId) } -func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverTransactor) CcipReceive(opts *bind.TransactOpts, arg0 ClientAny2EVMMessage) (*types.Transaction, error) { - return _MaybeRevertMessageReceiver.contract.Transact(opts, "ccipReceive", arg0) +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverTransactor) CcipReceive(opts *bind.TransactOpts, message ClientAny2EVMMessage) (*types.Transaction, error) { + return _MaybeRevertMessageReceiver.contract.Transact(opts, "ccipReceive", message) } -func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverSession) CcipReceive(arg0 ClientAny2EVMMessage) (*types.Transaction, error) { - return _MaybeRevertMessageReceiver.Contract.CcipReceive(&_MaybeRevertMessageReceiver.TransactOpts, arg0) +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverSession) CcipReceive(message ClientAny2EVMMessage) (*types.Transaction, error) { + return _MaybeRevertMessageReceiver.Contract.CcipReceive(&_MaybeRevertMessageReceiver.TransactOpts, message) } -func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverTransactorSession) CcipReceive(arg0 ClientAny2EVMMessage) (*types.Transaction, error) { - return _MaybeRevertMessageReceiver.Contract.CcipReceive(&_MaybeRevertMessageReceiver.TransactOpts, arg0) +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverTransactorSession) CcipReceive(message ClientAny2EVMMessage) (*types.Transaction, error) { + return _MaybeRevertMessageReceiver.Contract.CcipReceive(&_MaybeRevertMessageReceiver.TransactOpts, message) } func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverTransactor) SetErr(opts *bind.TransactOpts, err []byte) (*types.Transaction, error) { @@ -264,6 +286,30 @@ func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverTransactorSession) return _MaybeRevertMessageReceiver.Contract.SetRevert(&_MaybeRevertMessageReceiver.TransactOpts, toRevert) } +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverTransactor) WithdrawFunds(opts *bind.TransactOpts) (*types.Transaction, error) { + return _MaybeRevertMessageReceiver.contract.Transact(opts, "withdrawFunds") +} + +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverSession) WithdrawFunds() (*types.Transaction, error) { + return _MaybeRevertMessageReceiver.Contract.WithdrawFunds(&_MaybeRevertMessageReceiver.TransactOpts) +} + +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverTransactorSession) WithdrawFunds() (*types.Transaction, error) { + return _MaybeRevertMessageReceiver.Contract.WithdrawFunds(&_MaybeRevertMessageReceiver.TransactOpts) +} + +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverTransactor) WithdrawTokens(opts *bind.TransactOpts, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _MaybeRevertMessageReceiver.contract.Transact(opts, "withdrawTokens", token, amount) +} + +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverSession) WithdrawTokens(token common.Address, amount *big.Int) (*types.Transaction, error) { + return _MaybeRevertMessageReceiver.Contract.WithdrawTokens(&_MaybeRevertMessageReceiver.TransactOpts, token, amount) +} + +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverTransactorSession) WithdrawTokens(token common.Address, amount *big.Int) (*types.Transaction, error) { + return _MaybeRevertMessageReceiver.Contract.WithdrawTokens(&_MaybeRevertMessageReceiver.TransactOpts, token, amount) +} + func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error) { return _MaybeRevertMessageReceiver.contract.RawTransact(opts, nil) } @@ -276,6 +322,134 @@ func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverTransactorSession) return _MaybeRevertMessageReceiver.Contract.Receive(&_MaybeRevertMessageReceiver.TransactOpts) } +type MaybeRevertMessageReceiverFundsWithdrawnIterator struct { + Event *MaybeRevertMessageReceiverFundsWithdrawn + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *MaybeRevertMessageReceiverFundsWithdrawnIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(MaybeRevertMessageReceiverFundsWithdrawn) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + + select { + case log := <-it.logs: + it.Event = new(MaybeRevertMessageReceiverFundsWithdrawn) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +func (it *MaybeRevertMessageReceiverFundsWithdrawnIterator) Error() error { + return it.fail +} + +func (it *MaybeRevertMessageReceiverFundsWithdrawnIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type MaybeRevertMessageReceiverFundsWithdrawn struct { + Owner common.Address + Amount *big.Int + Raw types.Log +} + +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverFilterer) FilterFundsWithdrawn(opts *bind.FilterOpts, owner []common.Address) (*MaybeRevertMessageReceiverFundsWithdrawnIterator, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + + logs, sub, err := _MaybeRevertMessageReceiver.contract.FilterLogs(opts, "FundsWithdrawn", ownerRule) + if err != nil { + return nil, err + } + return &MaybeRevertMessageReceiverFundsWithdrawnIterator{contract: _MaybeRevertMessageReceiver.contract, event: "FundsWithdrawn", logs: logs, sub: sub}, nil +} + +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverFilterer) WatchFundsWithdrawn(opts *bind.WatchOpts, sink chan<- *MaybeRevertMessageReceiverFundsWithdrawn, owner []common.Address) (event.Subscription, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + + logs, sub, err := _MaybeRevertMessageReceiver.contract.WatchLogs(opts, "FundsWithdrawn", ownerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(MaybeRevertMessageReceiverFundsWithdrawn) + if err := _MaybeRevertMessageReceiver.contract.UnpackLog(event, "FundsWithdrawn", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverFilterer) ParseFundsWithdrawn(log types.Log) (*MaybeRevertMessageReceiverFundsWithdrawn, error) { + event := new(MaybeRevertMessageReceiverFundsWithdrawn) + if err := _MaybeRevertMessageReceiver.contract.UnpackLog(event, "FundsWithdrawn", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + type MaybeRevertMessageReceiverMessageReceivedIterator struct { Event *MaybeRevertMessageReceiverMessageReceived @@ -337,7 +511,12 @@ func (it *MaybeRevertMessageReceiverMessageReceivedIterator) Close() error { } type MaybeRevertMessageReceiverMessageReceived struct { - Raw types.Log + MessageId [32]byte + SourceChainSelector uint64 + Sender []byte + Data []byte + DestTokenAmounts []ClientEVMTokenAmount + Raw types.Log } func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverFilterer) FilterMessageReceived(opts *bind.FilterOpts) (*MaybeRevertMessageReceiverMessageReceivedIterator, error) { @@ -392,6 +571,143 @@ func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverFilterer) ParseMess return event, nil } +type MaybeRevertMessageReceiverTokensWithdrawnIterator struct { + Event *MaybeRevertMessageReceiverTokensWithdrawn + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *MaybeRevertMessageReceiverTokensWithdrawnIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(MaybeRevertMessageReceiverTokensWithdrawn) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + + select { + case log := <-it.logs: + it.Event = new(MaybeRevertMessageReceiverTokensWithdrawn) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +func (it *MaybeRevertMessageReceiverTokensWithdrawnIterator) Error() error { + return it.fail +} + +func (it *MaybeRevertMessageReceiverTokensWithdrawnIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type MaybeRevertMessageReceiverTokensWithdrawn struct { + Token common.Address + Owner common.Address + Amount *big.Int + Raw types.Log +} + +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverFilterer) FilterTokensWithdrawn(opts *bind.FilterOpts, token []common.Address, owner []common.Address) (*MaybeRevertMessageReceiverTokensWithdrawnIterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + + logs, sub, err := _MaybeRevertMessageReceiver.contract.FilterLogs(opts, "TokensWithdrawn", tokenRule, ownerRule) + if err != nil { + return nil, err + } + return &MaybeRevertMessageReceiverTokensWithdrawnIterator{contract: _MaybeRevertMessageReceiver.contract, event: "TokensWithdrawn", logs: logs, sub: sub}, nil +} + +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverFilterer) WatchTokensWithdrawn(opts *bind.WatchOpts, sink chan<- *MaybeRevertMessageReceiverTokensWithdrawn, token []common.Address, owner []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + + logs, sub, err := _MaybeRevertMessageReceiver.contract.WatchLogs(opts, "TokensWithdrawn", tokenRule, ownerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(MaybeRevertMessageReceiverTokensWithdrawn) + if err := _MaybeRevertMessageReceiver.contract.UnpackLog(event, "TokensWithdrawn", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverFilterer) ParseTokensWithdrawn(log types.Log) (*MaybeRevertMessageReceiverTokensWithdrawn, error) { + event := new(MaybeRevertMessageReceiverTokensWithdrawn) + if err := _MaybeRevertMessageReceiver.contract.UnpackLog(event, "TokensWithdrawn", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + type MaybeRevertMessageReceiverValueReceivedIterator struct { Event *MaybeRevertMessageReceiverValueReceived @@ -511,8 +827,12 @@ func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiverFilterer) ParseValu func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiver) ParseLog(log types.Log) (generated.AbigenLog, error) { switch log.Topics[0] { + case _MaybeRevertMessageReceiver.abi.Events["FundsWithdrawn"].ID: + return _MaybeRevertMessageReceiver.ParseFundsWithdrawn(log) case _MaybeRevertMessageReceiver.abi.Events["MessageReceived"].ID: return _MaybeRevertMessageReceiver.ParseMessageReceived(log) + case _MaybeRevertMessageReceiver.abi.Events["TokensWithdrawn"].ID: + return _MaybeRevertMessageReceiver.ParseTokensWithdrawn(log) case _MaybeRevertMessageReceiver.abi.Events["ValueReceived"].ID: return _MaybeRevertMessageReceiver.ParseValueReceived(log) @@ -521,8 +841,16 @@ func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiver) ParseLog(log type } } +func (MaybeRevertMessageReceiverFundsWithdrawn) Topic() common.Hash { + return common.HexToHash("0xeaff4b37086828766ad3268786972c0cd24259d4c87a80f9d3963a3c3d999b0d") +} + func (MaybeRevertMessageReceiverMessageReceived) Topic() common.Hash { - return common.HexToHash("0xd82ce31e3523f6eeb2d24317b2b4133001e8472729657f663b68624c45f8f3e8") + return common.HexToHash("0x707732b700184c0ab3b799f43f03de9b3606a144cfb367f98291044e71972cdc") +} + +func (MaybeRevertMessageReceiverTokensWithdrawn) Topic() common.Hash { + return common.HexToHash("0x6337ed398c0e8467698c581374fdce4db14922df487b5a39483079f5f59b60a4") } func (MaybeRevertMessageReceiverValueReceived) Topic() common.Hash { @@ -534,24 +862,42 @@ func (_MaybeRevertMessageReceiver *MaybeRevertMessageReceiver) Address() common. } type MaybeRevertMessageReceiverInterface interface { + BalanceOfToken(opts *bind.CallOpts, token common.Address) (*big.Int, error) + SToRevert(opts *bind.CallOpts) (bool, error) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) - CcipReceive(opts *bind.TransactOpts, arg0 ClientAny2EVMMessage) (*types.Transaction, error) + CcipReceive(opts *bind.TransactOpts, message ClientAny2EVMMessage) (*types.Transaction, error) SetErr(opts *bind.TransactOpts, err []byte) (*types.Transaction, error) SetRevert(opts *bind.TransactOpts, toRevert bool) (*types.Transaction, error) + WithdrawFunds(opts *bind.TransactOpts) (*types.Transaction, error) + + WithdrawTokens(opts *bind.TransactOpts, token common.Address, amount *big.Int) (*types.Transaction, error) + Receive(opts *bind.TransactOpts) (*types.Transaction, error) + FilterFundsWithdrawn(opts *bind.FilterOpts, owner []common.Address) (*MaybeRevertMessageReceiverFundsWithdrawnIterator, error) + + WatchFundsWithdrawn(opts *bind.WatchOpts, sink chan<- *MaybeRevertMessageReceiverFundsWithdrawn, owner []common.Address) (event.Subscription, error) + + ParseFundsWithdrawn(log types.Log) (*MaybeRevertMessageReceiverFundsWithdrawn, error) + FilterMessageReceived(opts *bind.FilterOpts) (*MaybeRevertMessageReceiverMessageReceivedIterator, error) WatchMessageReceived(opts *bind.WatchOpts, sink chan<- *MaybeRevertMessageReceiverMessageReceived) (event.Subscription, error) ParseMessageReceived(log types.Log) (*MaybeRevertMessageReceiverMessageReceived, error) + FilterTokensWithdrawn(opts *bind.FilterOpts, token []common.Address, owner []common.Address) (*MaybeRevertMessageReceiverTokensWithdrawnIterator, error) + + WatchTokensWithdrawn(opts *bind.WatchOpts, sink chan<- *MaybeRevertMessageReceiverTokensWithdrawn, token []common.Address, owner []common.Address) (event.Subscription, error) + + ParseTokensWithdrawn(log types.Log) (*MaybeRevertMessageReceiverTokensWithdrawn, error) + FilterValueReceived(opts *bind.FilterOpts) (*MaybeRevertMessageReceiverValueReceivedIterator, error) WatchValueReceived(opts *bind.WatchOpts, sink chan<- *MaybeRevertMessageReceiverValueReceived) (event.Subscription, error) diff --git a/core/gethwrappers/ccip/generation/generated-wrapper-dependency-versions-do-not-edit.txt b/core/gethwrappers/ccip/generation/generated-wrapper-dependency-versions-do-not-edit.txt index aa130bd644..74941808dd 100644 --- a/core/gethwrappers/ccip/generation/generated-wrapper-dependency-versions-do-not-edit.txt +++ b/core/gethwrappers/ccip/generation/generated-wrapper-dependency-versions-do-not-edit.txt @@ -16,7 +16,7 @@ evm_2_evm_onramp: ../../../contracts/solc/v0.8.24/EVM2EVMOnRamp/EVM2EVMOnRamp.ab fee_quoter: ../../../contracts/solc/v0.8.24/FeeQuoter/FeeQuoter.abi ../../../contracts/solc/v0.8.24/FeeQuoter/FeeQuoter.bin 503823a939ff99fe3bdaaef7a89cd4bbe475e260d3921335dbf9c80d4f584b76 lock_release_token_pool: ../../../contracts/solc/v0.8.24/LockReleaseTokenPool/LockReleaseTokenPool.abi ../../../contracts/solc/v0.8.24/LockReleaseTokenPool/LockReleaseTokenPool.bin 1067f557abeb5570f1da7f050ea982ffad0f35dc064e668a8a0e6af128df490c lock_release_token_pool_and_proxy: ../../../contracts/solc/v0.8.24/LockReleaseTokenPoolAndProxy/LockReleaseTokenPoolAndProxy.abi ../../../contracts/solc/v0.8.24/LockReleaseTokenPoolAndProxy/LockReleaseTokenPoolAndProxy.bin e632b08be0fbd1d013e8b3a9d75293d0d532b83071c531ff2be1deec1fa48ec1 -maybe_revert_message_receiver: ../../../contracts/solc/v0.8.24/MaybeRevertMessageReceiver/MaybeRevertMessageReceiver.abi ../../../contracts/solc/v0.8.24/MaybeRevertMessageReceiver/MaybeRevertMessageReceiver.bin d73956c26232ebcc4a5444429fa99cbefed960e323be9b5a24925885c2e477d5 +maybe_revert_message_receiver: ../../../contracts/solc/v0.8.24/MaybeRevertMessageReceiver/MaybeRevertMessageReceiver.abi ../../../contracts/solc/v0.8.24/MaybeRevertMessageReceiver/MaybeRevertMessageReceiver.bin 16455149f447d4a288f3c7acd00afbdfd594d2625a50f9858142fee46a4ab217 message_hasher: ../../../contracts/solc/v0.8.24/MessageHasher/MessageHasher.abi ../../../contracts/solc/v0.8.24/MessageHasher/MessageHasher.bin 0a2661da24147160383ad61d56a258515d1cc07f5e0f471ec5cbb4bccaf82389 mock_lbtc_token_pool: ../../../contracts/solc/v0.8.24/MockLBTCTokenPool/MockLBTCTokenPool.abi ../../../contracts/solc/v0.8.24/MockLBTCTokenPool/MockLBTCTokenPool.bin 1bb773ea4cd73712c84335de3e56afc2f738c9b96f3417316b5136e47591b5cc mock_usdc_token_messenger: ../../../contracts/solc/v0.8.24/MockE2EUSDCTokenMessenger/MockE2EUSDCTokenMessenger.abi ../../../contracts/solc/v0.8.24/MockE2EUSDCTokenMessenger/MockE2EUSDCTokenMessenger.bin d976651d36b33ac2196b32b9d2f4fa6690c6a18d41b621365659fce1c1d1e737 diff --git a/integration-tests/ccip-tests/actions/ccip_helpers.go b/integration-tests/ccip-tests/actions/ccip_helpers.go index c8edc5b2fb..0316c5f9db 100644 --- a/integration-tests/ccip-tests/actions/ccip_helpers.go +++ b/integration-tests/ccip-tests/actions/ccip_helpers.go @@ -57,6 +57,7 @@ import ( "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/evm_2_evm_onramp" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/evm_2_evm_onramp_1_2_0" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/fee_quoter" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/maybe_revert_message_receiver" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/mock_rmn_contract" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/rmn_contract" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router" @@ -1888,26 +1889,28 @@ func (sourceCCIP *SourceCCIPModule) CCIPMsg( func (sourceCCIP *SourceCCIPModule) SendRequest( receiver common.Address, gasLimit *big.Int, -) (common.Hash, time.Duration, *big.Int, error) { +) (common.Hash, time.Duration, *big.Int, []byte, error) { var d time.Duration destChainSelector, err := chainselectors.SelectorFromChainId(sourceCCIP.DestinationChainId) if err != nil { - return common.Hash{}, d, nil, fmt.Errorf("failed getting the chain selector: %w", err) + return common.Hash{}, d, nil, nil, fmt.Errorf("failed getting the chain selector: %w", err) } // form the message for transfer msg, err := sourceCCIP.CCIPMsg(receiver, sourceCCIP.Common.AllowOutOfOrder, gasLimit) if err != nil { - return common.Hash{}, d, nil, fmt.Errorf("failed forming the ccip msg: %w", err) + return common.Hash{}, d, nil, nil, fmt.Errorf("failed forming the ccip msg: %w", err) } + msgData := msg.Data + fee, err := sourceCCIP.Common.Router.GetFee(destChainSelector, msg) if err != nil { log.Info().Interface("Msg", msg).Msg("CCIP msg") reason, _ := blockchain.RPCErrorFromError(err) if reason != "" { - return common.Hash{}, d, nil, fmt.Errorf("failed getting the fee: %s", reason) + return common.Hash{}, d, nil, msgData, fmt.Errorf("failed getting the fee: %s", reason) } - return common.Hash{}, d, nil, fmt.Errorf("failed getting the fee: %w", err) + return common.Hash{}, d, nil, nil, fmt.Errorf("failed getting the fee: %w", err) } log.Info().Str("Fee", fee.String()).Msg("Calculated fee") @@ -1923,7 +1926,7 @@ func (sourceCCIP *SourceCCIPModule) SendRequest( if sendTx != nil { txHash = sendTx.Hash() } - return txHash, time.Since(timeNow), nil, fmt.Errorf("failed initiating the transfer ccip-send: %w", err) + return txHash, time.Since(timeNow), nil, nil, fmt.Errorf("failed initiating the transfer ccip-send: %w", err) } } else { sendTx, err = sourceCCIP.Common.Router.CCIPSendAndProcessTx(destChainSelector, msg, fee) @@ -1932,7 +1935,7 @@ func (sourceCCIP *SourceCCIPModule) SendRequest( if sendTx != nil { txHash = sendTx.Hash() } - return txHash, time.Since(timeNow), nil, fmt.Errorf("failed initiating the transfer ccip-send: %w", err) + return txHash, time.Since(timeNow), nil, nil, fmt.Errorf("failed initiating the transfer ccip-send: %w", err) } } @@ -1941,7 +1944,7 @@ func (sourceCCIP *SourceCCIPModule) SendRequest( Str("Send token transaction", sendTx.Hash().String()). Str("lane", fmt.Sprintf("%s-->%s", sourceCCIP.Common.ChainClient.GetNetworkName(), sourceCCIP.DestNetworkName)). Msg("Sending token") - return sendTx.Hash(), time.Since(timeNow), fee, nil + return sendTx.Hash(), time.Since(timeNow), fee, msgData, nil } func DefaultSourceCCIPModule( @@ -1987,6 +1990,7 @@ type DestCCIPModule struct { OffRamp *contracts.OffRamp ReportAcceptedWatcher *sync.Map ExecStateChangedWatcher *sync.Map + MessageReceivedWatcher *sync.Map ReportBlessedWatcher *sync.Map ReportBlessedBySeqNum *sync.Map NextSeqNumToCommit *atomic.Uint64 @@ -2115,6 +2119,8 @@ func (destCCIP *DestCCIPModule) RemoveAllRateLimitTokens(ctx context.Context) er return destCCIP.OffRamp.RemoveAllRateLimitTokens(ctx) } +var wasReceiverDappDeployed = false + // DeployContracts deploys all CCIP contracts specific to the destination chain func (destCCIP *DestCCIPModule) DeployContracts( sourceCCIP SourceCCIPModule, @@ -2235,6 +2241,10 @@ func (destCCIP *DestCCIPModule) DeployContracts( if err != nil { return fmt.Errorf("waiting for events on destination contract deployments %w", err) } + + log.Info().Str("Address", destCCIP.ReceiverDapp.Address()).Msg("Receiver Dapp Deployed") + + wasReceiverDappDeployed = true } else { destCCIP.ReceiverDapp, err = contractDeployer.NewReceiverDapp(destCCIP.ReceiverDapp.EthAddress) if err != nil { @@ -2697,6 +2707,74 @@ func (destCCIP *DestCCIPModule) AssertSeqNumberExecuted( } } +func (destCCIP *DestCCIPModule) AssertMessageContentMatch( + lggr *zerolog.Logger, + messageID string, + expectedContent []byte, + timeout time.Duration, + reqStat *testreporters.RequestStat, +) error { + lggr.Info(). + Str("MsgID", fmt.Sprintf("0x%x", string(messageID))). + Str("Timeout", timeout.String()). + Msg("Waiting for message content to match") + timer := time.NewTimer(timeout) + defer timer.Stop() + resetTimerCount := 0 + ticker := time.NewTicker(time.Second) + defer ticker.Stop() + for { + select { + case <-ticker.C: + // Load the message content from the watcher + value, ok := destCCIP.MessageReceivedWatcher.Load(messageID) + if !ok { + continue + } + + receivedContent, ok := value.([]uint8) + if !ok { + lggr.Warn(). + Str("MsgID", fmt.Sprintf("0x%x", string(messageID))). + Msg("Invalid content type in MessageReceivedWatcher") + return fmt.Errorf("invalid content type in MessageReceivedWatcher") + } + + // Compare the received content with the expected content + if string(receivedContent) == string(expectedContent) { + lggr.Info(). + Str("MessageID 0x%x", string(messageID)). + Str("Received Content", string(receivedContent)). + Str("Expected Content", string(expectedContent)). + Msg("Message received and its content matches the sent content") + return nil + } + + lggr.Warn(). + Str("MessageID 0x%x", string(messageID)). + Str("Received Content", string(receivedContent)). + Str("Expected Content", string(expectedContent)). + Msg("Message content mismatch") + + return fmt.Errorf("message content did not match for MessageID 0x%x", string(messageID)) + + case <-timer.C: + // Handle timeout with potential connection issue recovery + if destCCIP.Common.IsConnectionRestoredRecently != nil && !destCCIP.Common.IsConnectionRestoredRecently.Load() { + if resetTimerCount > 2 { + return fmt.Errorf("possible RPC issue - message content did not match for MessageID 0x%x", string(messageID)) + } + timer.Reset(timeout) + resetTimerCount++ + lggr.Info().Int("count of reset", resetTimerCount).Msg("Resetting timer to validate message content match") + continue + } + + return fmt.Errorf("timeout - message was not received for MessageID 0x%x", string(messageID)) + } + } +} + func DefaultDestinationCCIPModule( logger *zerolog.Logger, testConf *testconfig.CCIPTestGroupConfig, @@ -2726,6 +2804,7 @@ func DefaultDestinationCCIPModule( ReportBlessedBySeqNum: &sync.Map{}, ExecStateChangedWatcher: &sync.Map{}, ReportAcceptedWatcher: &sync.Map{}, + MessageReceivedWatcher: &sync.Map{}, }, nil } @@ -2734,6 +2813,7 @@ type CCIPRequest struct { txHash string txConfirmationTimestamp time.Time RequestStat *testreporters.RequestStat + MessageData []byte } func CCIPRequestFromTxHash(txHash common.Hash, chainClient blockchain.EVMClient) (CCIPRequest, *types.Receipt, error) { @@ -2886,7 +2966,7 @@ func (lane *CCIPLane) RecordStateBeforeTransfer() { lane.SentReqs = make(map[common.Hash][]CCIPRequest) } -func (lane *CCIPLane) AddToSentReqs(txHash common.Hash, reqStats []*testreporters.RequestStat) (*types.Receipt, error) { +func (lane *CCIPLane) AddToSentReqs(txHash common.Hash, reqStats []*testreporters.RequestStat, msgData []byte) (*types.Receipt, error) { request, rcpt, err := CCIPRequestFromTxHash(txHash, lane.Source.Common.ChainClient) if err != nil { for _, stat := range reqStats { @@ -2901,6 +2981,7 @@ func (lane *CCIPLane) AddToSentReqs(txHash common.Hash, reqStats []*testreporter txHash: rcpt.TxHash.Hex(), txConfirmationTimestamp: request.txConfirmationTimestamp, RequestStat: stat, + MessageData: msgData, }) lane.NumberOfReq++ } @@ -2987,7 +3068,7 @@ func (lane *CCIPLane) Multicall(noOfRequests int, multiSendAddr common.Address) } return fmt.Errorf("failed to send the multicall: %w", err) } - rcpt, err := lane.AddToSentReqs(tx.Hash(), reqStats) + rcpt, err := lane.AddToSentReqs(tx.Hash(), reqStats, nil) if err != nil { return err } @@ -3009,7 +3090,7 @@ func (lane *CCIPLane) Multicall(noOfRequests int, multiSendAddr common.Address) func (lane *CCIPLane) SendRequests(noOfRequests int, gasLimit *big.Int) error { for i := 1; i <= noOfRequests; i++ { stat := testreporters.NewCCIPRequestStats(int64(lane.NumberOfReq+i), lane.SourceNetworkName, lane.DestNetworkName) - txHash, txConfirmationDur, fee, err := lane.Source.SendRequest(lane.Dest.ReceiverDapp.EthAddress, gasLimit) + txHash, txConfirmationDur, fee, msgData, err := lane.Source.SendRequest(lane.Dest.ReceiverDapp.EthAddress, gasLimit) if err != nil { stat.UpdateState(lane.Logger, 0, testreporters.TX, txConfirmationDur, testreporters.Failure, nil) return fmt.Errorf("could not send request: %w", err) @@ -3026,7 +3107,7 @@ func (lane *CCIPLane) SendRequests(noOfRequests int, gasLimit *big.Int) error { noOfTokens++ } } - _, err = lane.AddToSentReqs(txHash, []*testreporters.RequestStat{stat}) + _, err = lane.AddToSentReqs(txHash, []*testreporters.RequestStat{stat}, msgData) if err != nil { return err } @@ -3301,41 +3382,52 @@ func (lane *CCIPLane) ValidateRequestByTxHash(txHash common.Hash, opts validatio if opts.phaseExpectedToFail == testreporters.Commit && opts.timeout != 0 { timeout = opts.timeout } + err = lane.Dest.AssertSeqNumberExecuted(lane.Logger, seqNumber, timeout, sourceLogFinalizedAt, reqStat) if shouldReturn, phaseErr := isPhaseValid(lane.Logger, testreporters.Commit, opts, err); shouldReturn { return phaseErr } // Verify whether commitStore has accepted the report - commitReport, reportAcceptedAt, err := lane.Dest.AssertEventReportAccepted( - lane.Logger, seqNumber, timeout, sourceLogFinalizedAt, reqStat, - ) - if shouldReturn, phaseErr := isPhaseValid(lane.Logger, testreporters.Commit, opts, err); shouldReturn { - return phaseErr - } + // commitReport, reportAcceptedAt, err := lane.Dest.AssertEventReportAccepted( + // lane.Logger, seqNumber, timeout, sourceLogFinalizedAt, reqStat, + // ) + // if shouldReturn, phaseErr := isPhaseValid(lane.Logger, testreporters.Commit, opts, err); shouldReturn { + // return phaseErr + // } + + // if opts.phaseExpectedToFail == testreporters.ReportBlessed && opts.timeout != 0 { + // timeout = opts.timeout + // } + // reportBlessedAt, err := lane.Dest.AssertReportBlessed(lane.Logger, seqNumber, timeout, *commitReport, reportAcceptedAt, reqStat) + // if shouldReturn, phaseErr := isPhaseValid(lane.Logger, testreporters.ReportBlessed, opts, err); shouldReturn { + // return phaseErr + // } + + // if opts.phaseExpectedToFail == testreporters.ExecStateChanged && opts.timeout != 0 { + // timeout = opts.timeout + // } + // // Verify whether the execution state is changed and the transfer is successful + // _, err = lane.Dest.AssertEventExecutionStateChanged( + // lane.Logger, seqNumber, + // timeout, + // reportBlessedAt, + // reqStat, + // testhelpers.ExecutionStateSuccess, + // ) + // if shouldReturn, phaseErr := isPhaseValid(lane.Logger, testreporters.ExecStateChanged, opts, err); shouldReturn { + // return phaseErr + // } + + if wasReceiverDappDeployed { + err = lane.Dest.AssertMessageContentMatch(lane.Logger, string(msgLog.MessageId[:]), []byte(lane.SentReqs[txHash][0].MessageData), timeout, reqStat) + if err != nil { + return errors.Wrap(err, "message validation failed") + } - if opts.phaseExpectedToFail == testreporters.ReportBlessed && opts.timeout != 0 { - timeout = opts.timeout - } - reportBlessedAt, err := lane.Dest.AssertReportBlessed(lane.Logger, seqNumber, timeout, *commitReport, reportAcceptedAt, reqStat) - if shouldReturn, phaseErr := isPhaseValid(lane.Logger, testreporters.ReportBlessed, opts, err); shouldReturn { - return phaseErr + log.Info().Msg("Message content validation successful") } - if opts.phaseExpectedToFail == testreporters.ExecStateChanged && opts.timeout != 0 { - timeout = opts.timeout - } - // Verify whether the execution state is changed and the transfer is successful - _, err = lane.Dest.AssertEventExecutionStateChanged( - lane.Logger, seqNumber, - timeout, - reportBlessedAt, - reqStat, - testhelpers.ExecutionStateSuccess, - ) - if shouldReturn, phaseErr := isPhaseValid(lane.Logger, testreporters.ExecStateChanged, opts, err); shouldReturn { - return phaseErr - } } if opts.expectAnyPhaseToFail { return fmt.Errorf("expected at least any one phase to fail but no phase got failed") @@ -3541,6 +3633,35 @@ func (lane *CCIPLane) StartEventWatchers() error { } }(reportAccSub) + messageReceivedEvent := make(chan *maybe_revert_message_receiver.MaybeRevertMessageReceiverMessageReceived) + messageReceivedSub := event.Resubscribe(DefaultResubscriptionTimeout, func(_ context.Context) (event.Subscription, error) { + sub, err := lane.Dest.ReceiverDapp.WatchMessageReceived(nil, messageReceivedEvent) + if err != nil { + log.Error().Err(err).Msg("error in subscribing to message received event") + } + return sub, err + }) + if messageReceivedSub == nil { + return fmt.Errorf("failed to subscribe to message received event") + } + go func(sub event.Subscription) { + defer sub.Unsubscribe() + for { + select { + case e := <-messageReceivedEvent: + messageId := string(e.MessageId[:]) + messageContent := e.Data + messageSender := string(e.Sender[:]) + log.Info().Msgf("Message event received for message id: 0x%x", messageId) + log.Info().Msgf("Message event received with content: %+v", string(messageContent)) + log.Info().Msgf("Message event received with sender: 0x%x", messageSender[len(messageSender)-20:]) + lane.Dest.MessageReceivedWatcher.Store(messageId, messageContent) + case <-lane.Context.Done(): + return + } + } + }(messageReceivedSub) + if lane.Dest.Common.ARM != nil { reportBlessedEvent := make(chan *rmn_contract.RMNContractTaggedRootBlessed) blessedSub := event.Resubscribe(DefaultResubscriptionTimeout, func(_ context.Context) (event.Subscription, error) { diff --git a/integration-tests/ccip-tests/contracts/contract_models.go b/integration-tests/ccip-tests/contracts/contract_models.go index 6d54117fd7..5a4bf5c45a 100644 --- a/integration-tests/ccip-tests/contracts/contract_models.go +++ b/integration-tests/ccip-tests/contracts/contract_models.go @@ -1099,6 +1099,18 @@ func (rDapp *ReceiverDapp) ToggleRevert(revert bool) error { return rDapp.client.ProcessTransaction(tx) } +func (rDapp *ReceiverDapp) WatchMessageReceived(opts *bind.WatchOpts, messageReceivedEvent chan *maybe_revert_message_receiver.MaybeRevertMessageReceiverMessageReceived) (event.Subscription, error) { + if rDapp.instance != nil { + return rDapp.instance.WatchMessageReceived(opts, messageReceivedEvent) + } + + newInstance, err := maybe_revert_message_receiver.NewMaybeRevertMessageReceiver(rDapp.EthAddress, wrappers.MustNewWrappedContractBackend(rDapp.client, nil)) + if err != nil { + return nil, fmt.Errorf("failed to create a new ReceiverDapp contract instance: %w", err) + } + return newInstance.WatchMessageReceived(opts, messageReceivedEvent) +} + type InternalTimestampedPackedUint224 struct { Value *big.Int Timestamp uint32 diff --git a/integration-tests/ccip-tests/load/helper.go b/integration-tests/ccip-tests/load/helper.go index f89aadc248..47e379809a 100644 --- a/integration-tests/ccip-tests/load/helper.go +++ b/integration-tests/ccip-tests/load/helper.go @@ -206,7 +206,7 @@ func (l *LoadArgs) ValidateCurseFollowedByUncurse() { // try to send requests on lanes on which curse is applied on source RMN and the request should revert // data-only transfer is sufficient lane.Source.TransferAmount = []*big.Int{} - failedTx, _, _, err := lane.Source.SendRequest(lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) + failedTx, _, _, _, err := lane.Source.SendRequest(lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) if lane.Source.Common.ChainClient.GetNetworkConfig().MinimumConfirmations > 0 { require.Error(l.t, err) } else { diff --git a/integration-tests/ccip-tests/smoke/ccip_test.go b/integration-tests/ccip-tests/smoke/ccip_test.go index 99c7a9012f..5f88ff95c8 100644 --- a/integration-tests/ccip-tests/smoke/ccip_test.go +++ b/integration-tests/ccip-tests/smoke/ccip_test.go @@ -249,7 +249,7 @@ func TestSmokeCCIPRateLimit(t *testing.T) { tc.lane.Source.Common.ChainClient.GetDefaultWallet(), src.Common.Router.Address(), src.TransferAmount[0]), ) require.NoError(t, tc.lane.Source.Common.ChainClient.WaitForEvents()) - failedTx, _, _, err := tc.lane.Source.SendRequest( + failedTx, _, _, _, err := tc.lane.Source.SendRequest( tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit), ) @@ -277,7 +277,7 @@ func TestSmokeCCIPRateLimit(t *testing.T) { // try to send again with amount more than the amount refilled by rate and // this should fail, as the refill rate is not enough to refill the capacity src.TransferAmount[0] = new(big.Int).Mul(AggregatedRateLimitRate, big.NewInt(10)) - failedTx, _, _, err = tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) + failedTx, _, _, _, err = tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) tc.lane.Logger.Info().Str("tokensToSend", src.TransferAmount[0].String()).Msg("More than Aggregated Rate") require.NoError(t, err) require.Error(t, tc.lane.Source.Common.ChainClient.WaitForEvents()) @@ -341,7 +341,7 @@ func TestSmokeCCIPRateLimit(t *testing.T) { src.TransferAmount[0] = tokensToSend tc.lane.Logger.Info().Str("tokensToSend", tokensToSend.String()).Msg("More than Token Pool Capacity") - failedTx, _, _, err = tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) + failedTx, _, _, _, err = tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) require.NoError(t, err) require.Error(t, tc.lane.Source.Common.ChainClient.WaitForEvents()) errReason, v, err = tc.lane.Source.Common.ChainClient.RevertReasonFromTx(failedTx, lock_release_token_pool.LockReleaseTokenPoolABI) @@ -373,7 +373,7 @@ func TestSmokeCCIPRateLimit(t *testing.T) { src.Common.ChainClient.GetDefaultWallet(), src.Common.Router.Address(), src.TransferAmount[0]), ) require.NoError(t, tc.lane.Source.Common.ChainClient.WaitForEvents()) - failedTx, _, _, err = tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) + failedTx, _, _, _, err = tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) require.NoError(t, err) require.Error(t, tc.lane.Source.Common.ChainClient.WaitForEvents()) errReason, v, err = tc.lane.Source.Common.ChainClient.RevertReasonFromTx(failedTx, lock_release_token_pool.LockReleaseTokenPoolABI) @@ -507,7 +507,7 @@ func TestSmokeCCIPOnRampLimits(t *testing.T) { src.TransferAmount[bpsTokenIndex] = big.NewInt(0) src.TransferAmount[aggRateTokenIndex] = overCapacityAmount src.TransferAmount[bpsAndAggTokenIndex] = big.NewInt(0) - failedTx, _, _, err := tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) + failedTx, _, _, _, err := tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) require.Error(t, err, "Limited token transfer should immediately revert") errReason, _, err := src.Common.ChainClient.RevertReasonFromTx(failedTx, evm_2_evm_onramp.EVM2EVMOnRampABI) require.NoError(t, err) @@ -519,7 +519,7 @@ func TestSmokeCCIPOnRampLimits(t *testing.T) { src.TransferAmount[aggRateTokenIndex] = big.NewInt(0) src.TransferAmount[bpsAndAggTokenIndex] = overCapacityAmount - failedTx, _, _, err = tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) + failedTx, _, _, _, err = tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) require.Error(t, err, "Limited token transfer should immediately revert") errReason, _, err = src.Common.ChainClient.RevertReasonFromTx(failedTx, evm_2_evm_onramp.EVM2EVMOnRampABI) require.NoError(t, err) @@ -567,7 +567,7 @@ func TestSmokeCCIPOnRampLimits(t *testing.T) { src.TransferAmount[bpsTokenIndex] = big.NewInt(0) src.TransferAmount[aggRateTokenIndex] = capacityLimit src.TransferAmount[bpsAndAggTokenIndex] = big.NewInt(0) - failedTx, _, _, err = tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) + failedTx, _, _, _, err = tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) require.Error(t, err, "Aggregate rate limited token transfer should immediately revert") errReason, _, err = src.Common.ChainClient.RevertReasonFromTx(failedTx, evm_2_evm_onramp.EVM2EVMOnRampABI) require.NoError(t, err) @@ -579,7 +579,7 @@ func TestSmokeCCIPOnRampLimits(t *testing.T) { src.TransferAmount[aggRateTokenIndex] = big.NewInt(0) src.TransferAmount[bpsAndAggTokenIndex] = capacityLimit - failedTx, _, _, err = tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) + failedTx, _, _, _, err = tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) require.Error(t, err, "Aggregate rate limited token transfer should immediately revert") errReason, _, err = src.Common.ChainClient.RevertReasonFromTx(failedTx, evm_2_evm_onramp.EVM2EVMOnRampABI) require.NoError(t, err) @@ -700,7 +700,7 @@ func TestSmokeCCIPTokenPoolRateLimits(t *testing.T) { // Send limited token over capacity and ensure it fails src.TransferAmount[freeTokenIndex] = big.NewInt(0) src.TransferAmount[limitedTokenIndex] = overCapacityAmount - failedTx, _, _, err := tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) + failedTx, _, _, _, err := tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) require.Error(t, err, "Limited token transfer should immediately revert") errReason, _, err := src.Common.ChainClient.RevertReasonFromTx(failedTx, lock_release_token_pool.LockReleaseTokenPoolABI) require.NoError(t, err) @@ -731,7 +731,7 @@ func TestSmokeCCIPTokenPoolRateLimits(t *testing.T) { // Send limited token over rate limit and ensure it fails src.TransferAmount[freeTokenIndex] = big.NewInt(0) src.TransferAmount[limitedTokenIndex] = capacityLimit - failedTx, _, _, err = tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) + failedTx, _, _, _, err = tc.lane.Source.SendRequest(tc.lane.Dest.ReceiverDapp.EthAddress, big.NewInt(actions.DefaultDestinationGasLimit)) require.Error(t, err, "Limited token transfer should immediately revert") errReason, _, err = src.Common.ChainClient.RevertReasonFromTx(failedTx, lock_release_token_pool.LockReleaseTokenPoolABI) require.NoError(t, err)