    fn receive_cross_chain_callback(
                ref self: ContractState,
                cross_chain_msg_id: felt252,
                from_chain: felt252,
                to_chain: felt252,
                from_handler: u256,
                to_handler: ContractAddress,
                cross_chain_msg_status: u8, <--
                sign_type: u8,
                signatures: Array<(felt252, felt252, bool)>,
            ) -> bool {
    //other functionality

    let success = handler.receive_cross_chain_callback(cross_chain_msg_id, from_chain, to_chain, from_handler, to_handler , cross_chain_msg_status);

                let mut state = CrossChainMsgStatus::PENDING;
                if success{
                    state = CrossChainMsgStatus::SUCCESS;
                }else{
                    state = CrossChainMsgStatus::FAILED;
                }

                self.created_tx.write(cross_chain_msg_id, CreatedTx{
                    tx_id:cross_chain_msg_id,
                    tx_status:state, <--- update the status 
                    from_chain: to_chain,
                    to_chain: from_chain,
                    from_handler: to_handler,
                    to_handler: from_handler
                });
            fn receive_cross_chain_callback(
                ref self: ContractState, 
                cross_chain_msg_id: felt252, 
                from_chain: felt252, 
                to_chain: felt252,
                from_handler: u256, 
                to_handler: ContractAddress, 
                cross_chain_msg_status: 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');

                let erc20 = IERC20MintDispatcher{contract_address: self.token_address.read()};

                if self.mode.read() == SettlementMode::MintBurn{
                    erc20.burn_from(get_contract_address(), self.created_tx.read(cross_chain_msg_id).amount);
                }

                let created_tx = self.created_tx.read(cross_chain_msg_id);
                
                self.created_tx.write(cross_chain_msg_id, CreatedCrossChainTx{
                    tx_id: created_tx.tx_id,
                    from_chain: created_tx.from_chain,
                    to_chain: created_tx.to_chain,
                    from:created_tx.from,
                    to:created_tx.to,
                    from_token: created_tx.from_token,
                    to_token: created_tx.to_token,
                    amount: created_tx.amount,
                    tx_status: CrossChainTxStatus::SETTLED
                });

                return true;
            }
        function processCrossChainCallback(
            uint256 txid,
            string memory from_chain,
            uint256 from_handler,
            address to_handler,
            CrossChainMsgStatus status,
            uint8 sign_type,
            bytes calldata signatures
        ) internal {
            require(
                create_cross_txs[txid].status == CrossChainMsgStatus.Pending,
                "Invalid transaction status"
            );

            if (
                ISettlementHandler(to_handler).receive_cross_chain_callback( 
                    txid,
                    from_chain,
                    from_handler,
                    status,
                    sign_type,
                    signatures
                )
            ) {
                create_cross_txs[txid].status = status; <---
            
            } else {
                create_cross_txs[txid].status = CrossChainMsgStatus.Failed;
            }
        }
                if success{
                    state = CrossChainMsgStatus::SUCCESS;
                if success{
                    state = cross_chain_msg_status;
