Coming from Solidity

contract Vault {
    error Insufficient(uint256 available, uint256 required);
    event Withdrawn(address indexed who, uint256 amount);
 
    mapping(address => uint256) public deposits;
 
    function deposit() external payable {
        deposits[msg.sender] += msg.value;
    }
 
    function withdraw(uint256 amount) external {
        uint256 have = deposits[msg.sender];
        if (have < amount) revert Insufficient(have, amount);
        deposits[msg.sender] = have - amount;
        emit Withdrawn(msg.sender, amount);
        (bool ok, ) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

import "std/evm";
 
error Insufficient of record {
  available : wei;
  required : wei;
}
 
event Withdrawn of record {
  indexed who : address;
  amount : wei;
}
 
storage is record {
  deposits : map(address, wei);
}
 
external view function deposits(const who : address) : wei is
  storage.deposits[who]
 
external payable function deposit() is {
  storage.deposits[Evm.sender()] := storage.deposits[Evm.sender()] + Evm.value();
}
 
external function withdraw(const amount : wei)
  raises Insufficient
is {
  const have : wei := storage.deposits[Evm.sender()];
  assert(have >= amount, Insufficient { available = have; required = amount; });
  storage.deposits[Evm.sender()] := have - amount;
  emit Withdrawn { who = Evm.sender(); amount = amount; };
  defer Evm.transfer(Evm.sender(), amount);
}