    fn receive_cross_chain_msg(/*params*/) -> bool {
    //rest of the code

    let success = handler.receive_cross_chain_msg(
                    cross_chain_msg_id, 
                    from_chain, //from_chain
                    to_chain,  //to_chain
                    from_handler, //from_handler
                    to_handler , //to_handler
                    payload     //payload
                );

                let mut status = CrossChainMsgStatus::SUCCESS;

                if success{
                    status = CrossChainMsgStatus::SUCCESS;
                }else{
                    status = CrossChainMsgStatus::FAILED;
                }

    }
            fn receive_cross_chain_msg(
                ref self: ContractState, 
                cross_chain_msg_id: u256, 
                from_chain: felt252, 
                to_chain: felt252,
                from_handler: u256, 
                to_handler: ContractAddress, 
                payload: Array<u8>
                ) -> bool{
                
                assert(to_handler == get_contract_address(),'error to_handler');

                assert(self.settlement_address.read() == get_caller_address(), 'not settlement');

                assert(self.support_handler.read((from_chain, from_handler)) && 
                        self.support_handler.read((to_chain, contract_address_to_u256(to_handler))), 
                        'not support handler'); 
                        //i.e (from_chain, to_handler)

                let message :Message= decode_message(payload);
                let payload_type = message.payload_type;
                
                assert(payload_type == PayloadType::ERC20, 'payload type not erc20');
                
                let payload_transfer = message.payload;
                
                let transfer = decode_transfer(payload_transfer);
                
                assert(transfer.method_id == ERC20Method::TRANSFER, 'ERC20Method must TRANSFER');
                
                let erc20 = IERC20MintDispatcher{contract_address: self.token_address.read()};
                let token = IERC20Dispatcher{contract_address: self.token_address.read()};

                // Handle the cross-chain transfer according to the settlement mode set in the contract.

                if self.mode.read() == SettlementMode::MintBurn{
                    erc20.mint_to(u256_to_contract_address(transfer.to), transfer.amount);
                
                }else if self.mode.read() == SettlementMode::LockMint{
                    erc20.mint_to(u256_to_contract_address(transfer.to), transfer.amount);
                
                }else if self.mode.read() == SettlementMode::BurnUnlock{
                    token.transfer(u256_to_contract_address(transfer.to), transfer.amount);
                
                }else if self.mode.read() == SettlementMode::LockUnlock{
                    token.transfer(u256_to_contract_address(transfer.to), transfer.amount);
                }
                
                return true;
            }
