feat: support constant arrays

This adds support for encoding constant arrays, rather than just zero
arrays.

Author: DavePearce

pkg/trace/lt/legacy_reader.go

@@ -225,6 +225,7 @@ func readWordColumnData(header legacyHeader, bytes []byte) array.MutArray[word.B
 		arr    = array.NewSmallArray[uint16, word.BigEndian](header.length, header.width*8)
 		offset = uint(0)
 		mx     uint16
+		zero   word.BigEndian
 	)
 	// Assign elements
 	for i := uint(0); i < header.length; i++ {
@@ -242,7 +243,7 @@ func readWordColumnData(header legacyHeader, bytes []byte) array.MutArray[word.B
 	//
 	switch {
 	case mx == 0:
-		return array.NewZeroArray[word.BigEndian](header.length)
+		return array.NewConstantArray[word.BigEndian](header.length, zero)
 	case mx < 256:
 		return readByteColumnData(header.length, bytes, 1, 2)
 	}

pkg/util/collection/array/builder.go

@@ -51,9 +51,11 @@ type staticArrayBuilder[T word.Word[T]] struct {
 
 // NewArray constructs a new word array with a given capacity.
 func (p *staticArrayBuilder[T]) NewArray(height uint, bitwidth uint) MutArray[T] {
+	var zero T
+	//
 	switch {
 	case bitwidth == 0:
-		return NewZeroArray[T](height)
+		return NewConstantArray(height, zero)
 	case bitwidth == 1:
 		arr := NewBitArray[T](height)
 		return &arr
@@ -87,9 +89,11 @@ type DynamicBuilder[T word.DynamicWord[T], P pool.Pool[uint32, T]] struct {
 
 // NewArray constructs a new word array with a given capacity.
 func (p *DynamicBuilder[T, P]) NewArray(height uint, bitwidth uint) MutArray[T] {
+	var zero T
+	//
 	switch {
 	case bitwidth == 0:
-		return NewZeroArray[T](height)
+		return NewConstantArray(height, zero)
 	case bitwidth == 1:
 		arr := NewBitArray[T](height)
 		return &arr
@@ -111,8 +115,8 @@ func (p *DynamicBuilder[T, P]) NewArray(height uint, bitwidth uint) MutArray[T]
 // when the encoding was made.
 func (p *DynamicBuilder[T, P]) Decode(encoding Encoding) MutArray[T] {
 	switch encoding.OpCode() {
-	case ENCODING_ZERO:
-		return decode_zero[T](encoding)
+	case ENCODING_CONSTANT:
+		return decode_constant[T](encoding)
 	case ENCODING_STATIC:
 		return decode_static[T](encoding)
 	case ENCODING_POOL:
@@ -131,8 +135,8 @@ func (p *DynamicBuilder[T, P]) Encode(array Array[T]) Encoding {
 	//
 	switch {
 	case bitwidth == 0:
-		encoding.Bytes = encode_zero(array.(*ZeroArray[T]))
-		encoding.Set(ENCODING_ZERO, bitwidth)
+		encoding.Bytes = encode_constant(array.(*ConstantArray[T]))
+		encoding.Set(ENCODING_CONSTANT, bitwidth)
 	case bitwidth == 1:
 		encoding.Bytes = encode_bits(array.(*BitArray[T]))
 		encoding.Set(ENCODING_STATIC, bitwidth)

pkg/util/collection/array/encoding.go

@@ -19,8 +19,8 @@ import (
 	"github.com/consensys/go-corset/pkg/util/word"
 )
 
-// ENCODING_ZERO is for arrays which hold constant values.
-const ENCODING_ZERO = 0
+// ENCODING_CONSTANT is for arrays which hold constant values.
+const ENCODING_CONSTANT = 0
 
 // ENCODING_STATIC is for arrays which hold their values explicitly.
 const ENCODING_STATIC = 1
@@ -64,12 +64,19 @@ func (p *Encoding) Set(opcode uint8, operand uint16) {
 // Constant Arrays
 // ============================================================================
 
-func decode_zero[T word.DynamicWord[T]](encoding Encoding) MutArray[T] {
-	var len = binary.BigEndian.Uint32(encoding.Bytes)
-	return NewZeroArray[T](uint(len))
+func decode_constant[T word.DynamicWord[T]](encoding Encoding) MutArray[T] {
+	var (
+		value    T
+		len      = binary.BigEndian.Uint32(encoding.Bytes)
+		constant = encoding.Operand()
+	)
+	//
+	value = value.SetUint64(uint64(constant))
+	//
+	return NewConstantArray[T](uint(len), value)
 }
 
-func encode_zero[T word.DynamicWord[T]](array *ZeroArray[T]) []byte {
+func encode_constant[T word.DynamicWord[T]](array *ConstantArray[T]) []byte {
 	var bytes [4]byte
 	//
 	binary.BigEndian.PutUint32(bytes[:], uint32(array.Len()))

pkg/util/collection/array/zero_array.go

@@ -23,73 +23,70 @@ import (
 // Implementation
 // =================================================================================
 
-// ZeroArray implements an array of single bit words simply using an underlying
-// array of packed bytes.  That is, where eight bits are packed into a single
-// byte.
-type ZeroArray[T word.Word[T]] struct {
+// ConstantArray implements an array of a constant value.
+type ConstantArray[T word.Word[T]] struct {
 	// Actual height of column
 	height uint
+	value  T
 }
 
-// NewZeroArray constructs a new word array with a given capacity.
-func NewZeroArray[T word.Word[T]](height uint) *ZeroArray[T] {
-	return &ZeroArray[T]{height}
+// NewConstantArray constructs a new word array with a given capacity.
+func NewConstantArray[T word.Word[T]](height uint, value T) *ConstantArray[T] {
+	return &ConstantArray[T]{height, value}
 }
 
 // Append new word on this array
-func (p *ZeroArray[T]) Append(word T) {
+func (p *ConstantArray[T]) Append(word T) {
 	p.Pad(0, 1, word)
 }
 
 // Clone makes clones of this array producing an otherwise identical copy.
-func (p *ZeroArray[T]) Clone() MutArray[T] {
-	return &ZeroArray[T]{p.height}
+func (p *ConstantArray[T]) Clone() MutArray[T] {
+	return &ConstantArray[T]{p.height, p.value}
 }
 
 // Len returns the number of elements in this word array.
-func (p *ZeroArray[T]) Len() uint {
+func (p *ConstantArray[T]) Len() uint {
 	return p.height
 }
 
 // BitWidth returns the width (in bits) of elements in this array.
-func (p *ZeroArray[T]) BitWidth() uint {
+func (p *ConstantArray[T]) BitWidth() uint {
 	return 0
 }
 
 // Build implementation for the array.Builder interface.  This simply means that
 // a static array is its own builder.
-func (p *ZeroArray[T]) Build() Array[T] {
+func (p *ConstantArray[T]) Build() Array[T] {
 	return p
 }
 
 // Get returns the field element at the given index in this array.
-func (p *ZeroArray[T]) Get(index uint) T {
-	var b T
-	// Default is zero
-	return b
+func (p *ConstantArray[T]) Get(index uint) T {
+	return p.value
 }
 
 // Set sets the field element at the given index in this array, overwriting the
 // original value.
-func (p *ZeroArray[T]) Set(index uint, word T) {
+func (p *ConstantArray[T]) Set(index uint, word T) {
 	// do nothing
 }
 
 // Pad implementation for MutArray interface.
-func (p *ZeroArray[T]) Pad(n uint, m uint, padding T) {
+func (p *ConstantArray[T]) Pad(n uint, m uint, padding T) {
 	p.height += n + m
 }
 
 // Slice out a subregion of this array.
-func (p *ZeroArray[T]) Slice(start uint, end uint) Array[T] {
+func (p *ConstantArray[T]) Slice(start uint, end uint) Array[T] {
 	var (
 		height = end - start
 	)
 	// Done
-	return &ZeroArray[T]{height}
+	return &ConstantArray[T]{height, p.value}
 }
 
-func (p *ZeroArray[T]) String() string {
+func (p *ConstantArray[T]) String() string {
 	var sb strings.Builder
 
 	sb.WriteString("[")