[chain] Introduce Multi-Actions and Outputs in Transactions

.github/workflows/hypersdk-ci.yml

@@ -133,7 +133,7 @@ jobs:
           MODE: 'test'
 
   tokenvm-load-tests:
-    needs: [tokenvm-unit-tests]
+    needs: [tokenvm-lint, tokenvm-unit-tests]
     strategy:
       matrix:
         level: [v1, v2, v3] # v4 is not supported
@@ -154,7 +154,7 @@ jobs:
         run: GOAMD64=${{ matrix.level }} scripts/tests.load.sh
 
   tokenvm-sync-tests:
-    needs: [tokenvm-unit-tests]
+    needs: [tokenvm-lint, tokenvm-unit-tests]
     runs-on: ubuntu-20.04-32
     timeout-minutes: 25
     steps:
@@ -255,7 +255,7 @@ jobs:
           MODE: 'test'
 
   morpheusvm-load-tests:
-    needs: [morpheusvm-unit-tests]
+    needs: [morpheusvm-lint, morpheusvm-unit-tests]
     strategy:
       matrix:
         level: [v1, v2, v3] # v4 is not supported
@@ -276,7 +276,7 @@ jobs:
         run: GOAMD64=${{ matrix.level }} scripts/tests.load.sh
 
   morpheusvm-sync-tests:
-    needs: [morpheusvm-unit-tests]
+    needs: [morpheusvm-lint, morpheusvm-unit-tests]
     runs-on: ubuntu-20.04-32
     timeout-minutes: 25
     steps:

README.md

@@ -648,24 +648,23 @@ type Action interface {
 	// key (formatted as a big-endian uint16). This is used to automatically calculate storage usage.
 	//
 	// If any key is removed and then re-created, this will count as a creation instead of a modification.
-	StateKeys(actor codec.Address, txID ids.ID) state.Keys
+	StateKeys(actor codec.Address, actionID codec.LID) state.Keys
 
 	// Execute actually runs the [Action]. Any state changes that the [Action] performs should
 	// be done here.
 	//
 	// If any keys are touched during [Execute] that are not specified in [StateKeys], the transaction
 	// will revert and the max fee will be charged.
-	//
-	// An error should only be returned if a fatal error was encountered, otherwise [success] should
-	// be marked as false and fees will still be charged.
+    //
+	// If [Execute] returns an error, execution will halt and any state changes will revert.
 	Execute(
 		ctx context.Context,
 		r Rules,
 		mu state.Mutable,
 		timestamp int64,
 		actor codec.Address,
-		txID ids.ID,
-	) (success bool, computeUnits uint64, output []byte, err error)
+		actionID codec.LID,
+	) (computeUnits uint64, outputs [][]byte, err error)
 }
 ```
 
@@ -743,6 +742,9 @@ type Rules interface {
 	GetMinBlockGap() int64      // in milliseconds
 	GetMinEmptyBlockGap() int64 // in milliseconds
 	GetValidityWindow() int64   // in milliseconds
+
+	GetMaxActionsPerTx() uint8
+	GetMaxOutputsPerAction() uint8
 
 	GetMinUnitPrice() Dimensions
 	GetUnitPriceChangeDenominator() Dimensions

chain/dependencies.go

@@ -124,6 +124,9 @@ type Rules interface {
 	GetMinEmptyBlockGap() int64 // in milliseconds
 	GetValidityWindow() int64   // in milliseconds
 
+	GetMaxActionsPerTx() uint8
+	GetMaxOutputsPerAction() uint8
+
 	GetMinUnitPrice() fees.Dimensions
 	GetUnitPriceChangeDenominator() fees.Dimensions
 	GetWindowTargetUnits() fees.Dimensions
@@ -238,24 +241,23 @@ type Action interface {
 	// key (formatted as a big-endian uint16). This is used to automatically calculate storage usage.
 	//
 	// If any key is removed and then re-created, this will count as a creation instead of a modification.
-	StateKeys(actor codec.Address, txID ids.ID) state.Keys
+	StateKeys(actor codec.Address, actionID codec.LID) state.Keys
 
 	// Execute actually runs the [Action]. Any state changes that the [Action] performs should
 	// be done here.
 	//
 	// If any keys are touched during [Execute] that are not specified in [StateKeys], the transaction
 	// will revert and the max fee will be charged.
 	//
-	// An error should only be returned if a fatal error was encountered, otherwise [success] should
-	// be marked as false and fees will still be charged.
+	// If [Execute] returns an error, execution will halt and any state changes will revert.
 	Execute(
 		ctx context.Context,
 		r Rules,
 		mu state.Mutable,
 		timestamp int64,
 		actor codec.Address,
-		txID ids.ID,
-	) (success bool, computeUnits uint64, output []byte, err error)
+		actionID codec.LID,
+	) (computeUnits uint64, outputs [][]byte, err error)
 }
 
 type Auth interface {

chain/errors.go

@@ -50,6 +50,8 @@ var (
 	ErrMisalignedTime       = errors.New("misaligned time")
 	ErrInvalidActor         = errors.New("invalid actor")
 	ErrInvalidSponsor       = errors.New("invalid sponsor")
+	ErrTooManyActions       = errors.New("too many actions")
+	ErrTooManyOutputs       = errors.New("too many outputs")
 
 	// Execution Correctness
 	ErrInvalidBalance  = errors.New("invalid balance")

chain/result.go

@@ -11,19 +11,35 @@ import (
 
 type Result struct {
 	Success bool
-	Output  []byte
+	Error   []byte
+
+	Outputs [][][]byte
 
 	Consumed fees.Dimensions
 	Fee      uint64
 }
 
 func (r *Result) Size() int {
-	return consts.BoolLen + codec.BytesLen(r.Output) + fees.DimensionsLen + consts.Uint64Len
+	outputSize := consts.Uint8Len // actions
+	for _, action := range r.Outputs {
+		outputSize += consts.Uint8Len
+		for _, output := range action {
+			outputSize += codec.BytesLen(output)
+		}
+	}
+	return consts.BoolLen + codec.BytesLen(r.Error) + outputSize + fees.DimensionsLen + consts.Uint64Len
 }
 
 func (r *Result) Marshal(p *codec.Packer) error {
 	p.PackBool(r.Success)
-	p.PackBytes(r.Output)
+	p.PackBytes(r.Error)
+	p.PackByte(uint8(len(r.Outputs)))
+	for _, outputs := range r.Outputs {
+		p.PackByte(uint8(len(outputs)))
+		for _, output := range outputs {
+			p.PackBytes(output)
+		}
+	}
 	p.PackFixedBytes(r.Consumed.Bytes())
 	p.PackUint64(r.Fee)
 	return nil
@@ -45,11 +61,20 @@ func UnmarshalResult(p *codec.Packer) (*Result, error) {
 	result := &Result{
 		Success: p.UnpackBool(),
 	}
-	p.UnpackBytes(consts.MaxInt, false, &result.Output)
-	if len(result.Output) == 0 {
-		// Enforce object standardization
-		result.Output = nil
+	p.UnpackBytes(consts.MaxInt, false, &result.Error)
+	outputs := [][][]byte{}
+	numActions := p.UnpackByte()
+	for i := uint8(0); i < numActions; i++ {
+		numOutputs := p.UnpackByte()
+		actionOutputs := [][]byte{}
+		for j := uint8(0); j < numOutputs; j++ {
+			var output []byte
+			p.UnpackBytes(consts.MaxInt, false, &output)
+			actionOutputs = append(actionOutputs, output)
+		}
+		outputs = append(outputs, actionOutputs)
 	}
+	result.Outputs = outputs
 	consumedRaw := make([]byte, fees.DimensionsLen)
 	p.UnpackFixedBytes(fees.DimensionsLen, &consumedRaw)
 	consumed, err := fees.UnpackDimensions(consumedRaw)
@@ -58,9 +83,7 @@ func UnmarshalResult(p *codec.Packer) (*Result, error) {
 	}
 	result.Consumed = consumed
 	result.Fee = p.UnpackUint64(false)
-	if !p.Empty() {
-		return nil, p.Err()
-	}
+	// Wait to check if empty until after all results are unpacked.
 	return result, p.Err()
 }