Comparison of two Ints leads to transaction error 9 — “Cell underflow”

[anstill]

Code in Tact:

let a: Int = 1;

let b:int = 2;

let c:int = -1;

if(a == b) {
// do smth
}

Generated code in Func:

int $a = 1;
int $b = 2;
int $c = (-1); 

 if (($a == $b)) {
    }

This leads to a transaction error 9 — “Cell underflow”.

I suppose generated code should look like this:

int $a = 1;
int $b = 2;
int $c = -1

 if ($a == $b) {
    }

[ex3ndr]

No, this couldn't be a reason. Error is thrown somewhere else.

[anstill]

@ex3ndr You are right, I found the reason. I'm using native udict_get_next to iterate on map keys.

struct DataRaw {
    key: Int;
    cs: Slice;
    f: Int;
}

struct Data {
    validUntil: Int as uint64;
    payload: Slice;
}

@name(udict_get_next?)
native mapGetNext(map: map[Int]Data, keyLen: Int, pivot: Int): DataRaw;

contract HasMapContract with Deployable, Ownable {  
  data: map[Int]Data;
  
  receive(msg: Delete) {
    // ...code
    
    let nextKey: DataRaw = mapGetNext(self.data, 256, -1);
    
    if(nextKey.key == 1) {
      // this if triggers error;
    } 
    
  }

Do you know what is wrong here? I am also looking for a proper way to iterate on the map keys without knowing them.

[ex3ndr]

I am thinking about a solution, but it is not possible for now.

But your dict ops are for unsigned keys, but singed one is defined.

[anstill]

@ex3ndr I tried to change different types of variables, but still getting errors when interacting with any variable from udict_get_next.

The declaration looks like this now:

struct Data {
    validUntil: Int as uint64;
    payload: Slice;
}

struct DataRaw {
    key: Int? as uint256;
    cs: Slice?;
    f: Int;
}

@name(udict_get_next?)
native mapGetNext(map: map[Int]Data, keyLen: Int, pivot: Int): DataRaw;

I also encountered the inability to determine the dimension of Int in variable and map declaration.

// Doesn't work
let key: Int as uint256 = 1;
let map: map[Int]Int = null; // impossible to create new map outside contract definition

struct Data {
  map: map[Int as uint256]Int;
}

[ex3ndr]

Because it currently supports only 257 bit keys

[anstill]

@ex3ndr

I'm trying to extend the map, but unfortunately, the compiler does not allow me to do this.

@name(udict_get_next?)
extends native mapGetNext(self: map[Int]Int, keyLen: Int, pivot: Int): DataRaw; 

  30 | @name(udict_get_next?)
> 31 | extends native mapGetNext(self: map[Int]Int, keyLen: Int, pivot: Int): DataRaw;
                                 ^~~~~~~~~~~~~~~~~
  32 | 
Extend functions must have a reference type as the first argument

As the map represents a Cell I think it is possible to save it as a ref beginCell().storeRef(self.map).endCell().

This makes it impossible to work with map as Cell even if change declaration like this:

@name(udict_get_next?)
extends native mapGetNext(self: Cell, keyLen: Int, pivot: Int): DataRaw; 

Because there is no way to convert Map to the Cell e.g. self.map.toCell()

[ex3ndr]

You can just create non-extended function, but a just native one

[anstill]

It doesn't work, for example

struct DataRaw {
    key: Int;
    cs: Slice;
    f: Int;
}

@name(udict_get_next?)
native mapGetNext(map: map[Int]Data, keyLen: Int, pivot: Int): DataRaw;

// ...

let nextKey: DataRaw = mapGetNext(self.data, 256, key);  // or 257

abi.dump(nextKey.f);

Any interaction with nextKey field throws a 9th exit code.

[ex3ndr]

udict_get_next is for unsinged keys value, idict_get_next must be used instead with 257 bit keys.

[anstill]

Thanks, it's working!

[tactfunc]

what is this code about?

And using like native mapGetNext(map: map[Int]Data, keyLen: Int, pivot: Int): DataRaw; is a proper way to do to claim new data time like this?