BlockId implementation

[aaroncox]

No description provided.

[jnordberg]

We should verify this to be sure but I don't think there is a block_id builtin type so this could end up causing inconsistencies when decoding with core vs nodeos

[aaroncox]

I'm not sure if I'm looking in the right place, but I do see this:

https://github.com/AntelopeIO/leap/blob/bd75cf0e3b8a95296a47a1d073da328c2e8854a3/libraries/chain/eosio_contract_abi.cpp#L14

I can remove it if it's not a legit type - just not sure where exactly to find the builtins for nodeos.

[jnordberg]

Yeah hard to say, I checked now in the abieos lib and it doesn't define it. One way to know for sure is to define an ABI that depends on the "block_id_type" and ask nodeos/cleos to decode it and see if that works

[aaroncox]

I removed the the BlockId from the builtins and changed all the predefined types to use it instead of the alias 👍

[jnordberg]

BlockId isn't actually a checksum, it's derived from a checksum but BlockId.hash() doesn't have a meaning so I think we should just inherit from Struct and keep it in its own file. Also it would be neat if it had a from method that accepted a Checksum256 and a number (that could replace the .id getter in p2p/types.ts)

[aaroncox]

I'm having a hell of a time figuring out how the Struct would be built for this without using the Checksum 🤔

export class BlockId extends Struct {
    @Struct.field('bytes[]', {array: true}) declare array: Bytes[]
}

This isn't right, I think I need a UInt8array ti be stored on the struct to work like a checksum? Any pointers here?

[jnordberg]

You'd set the field to something like @Struct.field('bytes') declare data: Bytes and then access the data.array. But actually thinking more about this now a better approach is to just implement a new AbiSerializable type for this case. Something like:

type BlockIdType = BlockId | BytesType | {blockNum: UInt32Type; checksum: Checksum256Type}

export class BlockId implements ABISerializableObject {
    static abiName = 'block_id_type' // eosio contract context defines this with a _type suffix for some reason

    static from(value: BlockIdType) {
        if (isInstanceOf(value, this)) {
            return value
        }
        if (Bytes.isBytes(value)) {
            return new this(Bytes.from(value).array)
        } else {
            return this.fromBlockChecksum(value.checksum, value.blockNum)
        }
    }

    static fromBlockChecksum(checksum: Checksum256Type, blockNum: UInt32Type): BlockId {
        // move helper from p2p here
    }

    readonly array: Uint8Array

    constructor(array: Uint8Array) {
        if (array.byteLength !== 32) {
            throw new Error(`BlockId size mismatch, expected 32 bytes got ${array.byteLength}`)
        }
        this.array = array
    }

    equals(other: BlockIdType): boolean {
        const self = this.constructor as typeof BlockId
        try {
            return arrayEquals(this.array, self.from(other).array)
        } catch {
            return false
        }
    }

    get hexString(): string {
        return arrayToHex(this.array)
    }

    toABI(encoder: ABIEncoder) {
        encoder.writeArray(this.array)
    }

    toString() {
        return this.hexString
    }

    toJSON() {
        return this.toString()
    }

    // add helper methods here
}

[jnordberg]

Reason being that Bytes packs its own length as a varuint prefix while Checksum/BlockId doesn't

[aaroncox]

I have this all setup now and my tests are passing, but the p2p tests are now failing with "invalid type" 🤔

Is this because the serialized data in the unit tests no longer is valid for the tests, or did I miss something?

This error is so deep in the serializer, I'm a bit lost lol

[jnordberg]

Ah, I forgot to add the fromABI to the template above.

    static fromABI(decoder: ABIDecoder) {
        return new this(decoder.readArray(32))
    }

Add that and see it works

[aaroncox]

That did it! Honestly I never would have come to that conclusion from the error. I've still got a lot to learn when it comes to the internals of the serializer!