https://github.com/LimeChain/goscale/blob/master/boolean.go

Variable Width Integers

https://github.com/LimeChain/goscale/blob/master/length_compact.go

There is a separate issue to handle:

Regardless of whether the Option has value or not, it will always encode the value (default if empty)

type TupleOption struct {
	Tuple
	M0 Option[U8]
	M1 Option[Bool]
	M2 Option[Str]
}

func Test_EncodeTupleOption(t *testing.T) {
	var testExamples = []struct {
		label       string
		input       TupleOption
		expectation []byte
	}{
		{
			label: "TupleOption",
			input: TupleOption{
				M0: Option[U8]{true, 3},
				M1: Option[Bool]{true, false},
				M2: NewOption[Str](nil),
			},
			expectation: []byte{
				0x01, 0x03, // M0
				0x01, 0x00, // M1
				0x00, // M2
			},
		},
	}

	for _, testExample := range testExamples {
		t.Run(testExample.label, func(t *testing.T) {
			buffer := &bytes.Buffer{}

			EncodeTuple(testExample.input, buffer)

			assertEqual(t, buffer.Bytes(), testExample.expectation)
		})
	}
}

With the current reflect support in Tinygo we can't get the types T, E in Option[T], Result[T, E].

https://github.com/LimeChain/goscale/tree/tuple-decode-impl

Panicking is not particularly helpful, especially in the Runtime. Instead, errors should be passed on to the Host. To accomplish that, all Decode functions should be refactored to return an error in addition to their current output, rather than simply panicking.

Example:

func DecodeBool(buffer *bytes.Buffer) Bool

should be

func DecodeBool(buffer *bytes.Buffer) (Bool, error)

• byte slice
• string slice
• slice of any type

Related: #16

FixedSequence type needs to be represented by an array type , but currently it is not possible to be parameterized.

https://github.com/LimeChain/goscale/blob/master/fixed_length.go

There is a separate issue to handle:

Array types have fixed size known at compile time, thus the size encoding is omitted.

From the spec:
In some cases, the length indicator is omitted if the length of the sequence is fixed and known by the decoder upfront. Such cases are explicitly stated by the definition of the corresponding type.

Go proposal that might help to make generic parameterized encoding of Array (Sequence with fixed size): golang/go#44253

Related: #4

Since U8 is used extensively, e.g. Sequence[U8], invoking value.Bytes() to return the bytes causes a significant performance overhead with the custom gc, and it tries to allocate single allocation bigger than the max possible.

func (value U8) Encode(buffer *bytes.Buffer) {
	encoder := Encoder{Writer: buffer}
	encoder.Write(value.Bytes())
}

func (value U8) Bytes() []byte {
	return []byte{byte(value)}
}

Instead encode the bytes directly

encoder.EncodeByte(byte(value))

• Decode size
• Iterate and decode key, value

https://spec.polkadot.network/#defn-result-type

Option<Result> issue:
golang/go#54393
golang/go#50741

Declarations of Option[T] and Result[T, E] value types can specify custom-defined types for T and E.

Example:

type MyOk struct {}
type MyError struct {}

...

buffer := &bytes.Buffer{}
Result[MyOk, MyError]{}.Encode(buffer)

Currently, DecodeResult relies on the convention that for each type there is a Decode<TypeName> function. It invokes the decode function only for the predefined types, not for custom-defined ones.

res := DecodeResult[MyOk, MyError](buffer)

We need to be able to dynamically build/call the corresponding decode function for the specified type using reflection.

Approach 1: Obtain the full package name of the corresponding function. We could potentially derive it from the Type. However, we'll rely on the convention that the decode function is defined in the same package.

Approach 2: Include a Decode method as part of the interface, so there will be type checks, and each type will have a Decode method that can be called using reflection.

Related #62

Implement a generic function that converts any Sequence or FixedSequence to bytes

Previously there were some issues with the compiler #38.

type SequentialU8 interface {
	Sequence[U8] | FixedSequence[U8]
}

func SequentialU8ToBytes[S SequentialU8](bytes S) []byte {
	result := make([]byte, len(bytes))
	for i, v := range bytes {
		result[i] = byte(v)
	}
	return result
}

Related to this issue: LimeChain/gosemble#262

Fixed Length Integers implementation for i128 and u128

• finish the implementation of I128
• revise the implementation of all Operations (Add, Mul, Div, etc.) for all types U/I 8/16/32/64 and U/I 128 to have similar behavior
  • Operation - wraps around
  • SaturatingOperation - saturates at the boundaries
  • CheckedOperation - returns error
• rename NewU128FromUint64 to NewU128
• add support for passing any numeric type to NewU128/NewI128
• add support for passing string literals NewU128("12749827981791739187398173981")
• finish the implementation of To[N] (revise type conversion)
• add tests
• inline docs
  * [ ] extract it into a separate package (num or numeric), for ease of use and rename NewNumeric to New
  ex: num.New[U128]
  ex: num.To[U64]

related #82

• encoding struct with fields of any SCALE type (using the default fields order)

  • tinygo-org/tinygo#3328
  • encoding of Dictionary type of fields is implemented only for keys of type Str

• decoding struct with fields of any SCALE type (using the default fields order)

  • panic("unimplemented: reflect.MakeSlice()")
  • panic("unimplemented: (reflect.Value).Addr()")

• struct tags - allow modification of the struct field ordering, that preserve the encoding/decoding order.

Try to do optimizations as much as possible since SCALE codec is heavily utilized on almost every occasion.
Related #77

https://docs.rs/num/latest/num/fn.clamp.html. Go through gosemble TODOs to check where to call it.