Did I just lose half a million dollars?

Post by capableweb » Sun, Jan 30, 2022, 1:49 PM UTC

zkldi wrote: post #316

capableweb wrote: post #294

Earlier quoted context omitted.

> You'd expect that invalid actions lead to idempotent errors, not glitch states where you lose everything. Indeed, and that's exactly how most cryptocurrencies work today. You try to send funds to an invalid address, the wallet will present you with an error that you cannot do that. The user in the submission did not perform an invalid action, because they wouldn't be able to perform an invalid action.

So your definition for "valid action" is just that the eth network lets them do it? They clearly didn't want to burn £500k, and that is now irrecoverable, alongside 260 other people who made the same mistake, on a smart contract that forgoes validation for gas fees. How is this not invalid?

Post by sanderjd » Sun, Jan 30, 2022, 1:51 PM UTC

SwiftyBug wrote: post #100

BatteryMountain wrote: post #87

Earlier quoted context omitted.

It truly is laughable. Ever heard of "Return to Sender" in case of invalid events/transactions?

YES. Weren't these supposed to be SMART contracts? My email provider is smarter than that.

Post by hashimotonomora » Sun, Jan 30, 2022, 1:52 PM UTC

axiosgunnar wrote: post #323

sshine wrote: post #275

Earlier quoted context omitted.

When I do money transfers on bank accounts, I read the 10 digits 4-5 times. If the person that I'm transfering to is in the room, I ask them to read aloud their account number as I follow. The fact that you have to get 10 digits right and that a typo can result in sending the money off somewhere unknown, disturbs me a lot. It's amazing how cryptocurrencies mimicked that part about existing digital money to perfection…

Account numbers have checksums. An „off by one“ typo cannot occur.

Post by erikbye » Sun, Jan 30, 2022, 1:54 PM UTC

iqanq wrote: post #164

doteka wrote: post #147

Earlier quoted context omitted.

It abstracts away underlying hardware, leaving you with a convenient set of abstractions for deploying containerized networked services. Sort of an OS for a cluster of distributed machines. Unfortunately this involves lots of YAML. How’d I do?

One could write a sentence like that about smart contracts. One I pulled from Google: Smart contracts are simply programs stored on a blockchain that run when predetermined conditions are met. They typically are used to automate the execution of an agreement so that all participants can be immediately certain of the outcome, without any intermediary’s involvement or time loss. They can also automate a workflow, trigg…

  contract WETH9 {
    string public name     = "Wrapped Ether";
    string public symbol   = "WETH";
    uint8  public decimals = 18;

    event  Approval(address indexed src, address indexed guy, uint wad);
    event  Transfer(address indexed src, address indexed dst, uint wad);
    event  Deposit(address indexed dst, uint wad);
    event  Withdrawal(address indexed src, uint wad);

    mapping (address => uint)                       public  balanceOf;
    mapping (address => mapping (address => uint))  public  allowance;

    function() public payable {
        deposit();
    }
    function deposit() public payable {
        balanceOf[msg.sender] += msg.value;
        Deposit(msg.sender, msg.value);
    }
    function withdraw(uint wad) public {
        require(balanceOf[msg.sender] >= wad);
        balanceOf[msg.sender] -= wad;
        msg.sender.transfer(wad);
        Withdrawal(msg.sender, wad);
    }

    function totalSupply() public view returns (uint) {
        return this.balance;
    }

    function approve(address guy, uint wad) public returns (bool) {
        allowance[msg.sender][guy] = wad;
        Approval(msg.sender, guy, wad);
        return true;
    }

    function transfer(address dst, uint wad) public returns (bool) {
        return transferFrom(msg.sender, dst, wad);
    }

    function transferFrom(address src, address dst, uint wad)
        public
        returns (bool)
    {
        require(balanceOf[src] >= wad);

        if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) {
            require(allowance[src][msg.sender] >= wad);
            allowance[src][msg.sender] -= wad;
        }

        balanceOf[src] -= wad;
        balanceOf[dst] += wad;

        Transfer(src, dst, wad);

        return true;
    }
}

Post by ljm » Sun, Jan 30, 2022, 1:55 PM UTC

XorNot wrote: post #146

jazzyjackson wrote: post #123

Earlier quoted context omitted.

from the reddit comments, similar question, apparently every instruction adds gas fees to running the contract, so if you're going to use the contract a lot, you leave out any kind of validation. >> Wow why didn't the contract creators think this through and block requests to the contract > Because adding that check would increase the cost of every user transaction. All AMM swaps would be done with WETH so it’s the r…

I really can't think of an expression other then "lol" to sum up my response here for just how incredibly stupid this is, as a "platform of the future". A design which actively discourages robust programming and error handling in financial software. Wow .