Add some helper functions to deal with multiple tags at once. Such as ways to compute the size of a sequence of tags along other functions.

Add macro functions to serialize sequences of tags. Those functions will take advantage of the varargs feature of Go.

The function TimestampTagSize() missing.

Update testify to v1.8.1.

ComputeagHeaderSize() does not have unit-tests.

Add a simple way to version tag payloads. The current suggestion is to format the payload with a version prefix and a way to put the actual payload after that.

Add the extended implementation of the tag ChainNameBlockRefTag. The ChainNameBlockRefTag is a tag with no fixed ID that contains 2 tags inside, a StringTag with a custom ID that holds the chain name followed by a ILIntTag that holds the block ID.

As an extended tag, it does not enforce fixed IDs to its components.

Add new helper functions that deal with tags that can be optionally null.

Remove all . imports from the library.

Remove the deprecated function ComputeagHeaderSize().

ILTagSeralizeWithNull() is not properly detecting nil pointers when the pointer is typed.

Move StableStringMap from tags.impl to utils. However, keep an alias to the type inside tags to keep the libray backward compatible with previous versions.

Rename function ComputeagHeaderSize() to ComputeHeaderSize(). Leave a pointer to the wrong name but marked as deprecated.

Change error messages to match the Go convention instead of the original Rust port.

Add direct serialization/deserialization functions for the TimestapTag. This function will be a shell around SerializeSignedILIntTag() and DeserializeSignedILIntTag().

Add the support for the IL2 versioned payload scheme. This scheme uses a ILUint16Tag to encode the version instead of the plain uint16 value used by the implementation introduced in the version v0.1.1 of this library.

While the main advantage of the scheme used by VersionedPayload from this library is its compact size, the scheme defined by IL2 has the advantage to be compatible with an ILTagSequenceTag.

The idea is to keep both schemes in the library as VersionedPayload is suitable for raw payloads and the IL2 scheme is perfect for tag sequence payloads.

This enhancement was motivated by a post by @monoman at issue #3 (comment).

Add the concept of WrappedValueTag. This ILTag extension will define an interface where the tag implementation actually wraps the value it will serialize.

For instance, a ATag that implements the WrappedValueTag interface will have the value A as the wrapped value. On serialization, it will be used as to get the information to serialize. On deserialization, a new instance of this value is created by the deserialization process.

Create a package with testing utilities. Those utilities may be used by users of the library to implement their own tags.

Add helper functions to serialize/deserialize implicit tags without instantiate them. It will follow the same idea of the helper functions:

• StringTagSize(tagId tags.TagID, s string) uint64
• StdStringTagSize(s string) uint64
• SerializeStringTag(tagId tags.TagID, s string, writer io.Writer) error
• DeserializeStringTag(expectedId tags.TagID, reader io.Reader) (string, error)
• SerializeStdStringTag(s string, writer io.Writer) error
• DeserializeStdStringTag(reader io.Reader) (string, error)

All reserved implicit tags needs to have their own functions.

Move the implementation of the RawTag from tags.impl to tags.

Add a generic timestamp tag implementation. This tag should represent a timestamp in microseconds since 1970-01-01T00:00:00.000000Z.

The serialization should be identical to the SignedILIntTag but its implementation must define methods to integrate with the standard time package.