Incorrect bit length in `.storeUint()` and `.storeInt()` functions fails silently in presence of serialization/storage modifiers when doing parsing via `Struct.fromCell()`

novusnota commented 4 days ago

Consider the following snippet:

import "@stdlib/deploy";

struct Coin {
    first: Int as coins;
    second: Int as uint32;
}

fun directParse(payload: Cell): Coin {
    return Coin.fromCell(payload);
}

contract Example with Deployable {
    receive("example") {
        let coin = directParse(
            beginCell()
            .storeCoins(42)
            .storeUint(35, 31) // here, I only specified 31 bit for storing the Uint, but could've specified 33 bits and get the same issue
            .endCell()
        );
        dump(coin.first); // would display nothing!
        dump(coin.second); // neither would this!
    }
}

Although it's up to user to correctly specify serialization modifiers, such as uint32 and then use .storeUint(NUM_TO_STORE, 32) and similar, it would be nice to display an error when mistakes occur.

This may be an edge case of some bigger issue.

Also it's unknown what value coin has in the showcased example, because an attempt to dump(coin) will be prohibited as dump() doesn't support Structs and Messages directly and type of coin is still considered to be Coin.

P.S.: Kinda offtopic, but this reminded me that we may consider adding .storeUint32(), .storeUint64() and similar functions for convenience. Or, to make a special function for Ints, which would accept serialization modifiers, like so:

// Option 1
beginCell().storeValue(VALUE as uint32);

// Option 2
beginCell().storeValue(VALUE, uint32);

Gusarich commented 23 hours ago

What do you mean by "fails silently"? I've just ran that code and it resulted exit code 9 - just as expected.