103: func (ob *EVMChainClient) GetInboundVoteMsgForDepositedEvent(event *erc20custody.ERC20CustodyDeposited) (types.MsgVoteOnObservedInboundTx, error) {
...   // [...]
115: 	signer := ethtypes.NewLondonSigner(big.NewInt(ob.chain.ChainId))
116: 	sender, err := signer.Sender(tx)
117: 	if err != nil {
118: 		ob.logger.ExternalChainWatcher.Error().Err(err).Msg(fmt.Sprintf("can't recover the sender from the tx hash: %s", event.Raw.TxHash.Hex()))
119: 		return types.MsgVoteOnObservedInboundTx{}, errors.Wrap(err, fmt.Sprintf("can't recover the sender from the tx hash: %s", event.Raw.TxHash.Hex()))
120:
121: 	}
122: 	return *GetInBoundVoteMessage(
123:  		sender.Hex(),
124: 		ob.chain.ChainId,
125: 		"",
126: 		clienttypes.BytesToEthHex(event.Recipient),
127: 		common.ZetaChain().ChainId,
128: 		sdkmath.NewUintFromBigInt(event.Amount),
129: 		hex.EncodeToString(event.Message),
130: 		event.Raw.TxHash.Hex(),
131: 		event.Raw.BlockNumber,
132: 		1_500_000,
133: 		common.CoinType_ERC20,
134: 		event.Asset.String(),
135: 		ob.zetaClient.GetKeys().GetOperatorAddress().String(),
136: 		event.Raw.Index,
137: 	), nil
138: }
contract Escrow {
    ERC20Custody public custody;
    mapping (address => mapping (IERC20 => uint256)) public escrowed;
    address owner;

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function.");
        _;
    }

    constructor(ERC20Custody custody_, address owner_) {
        custody = custody_;
        owner = owner_;
    }

    function escrow(IERC20 asset, uint256 amount) {
        asset.transferFrom(msg.sender, address(this), amount);

        escrowed[msg.sender][asset] += amount;
    }

    function bridge(
        bytes calldata recipient,
        IERC20 asset,
        uint256 amount,
        bytes calldata message
    ) external onlyOwner {
        asset.approve(address(custody), amount);
        custody.deposit(recipient, asset, amount, message);
    }
}
