Merge pull request #423 from iotaledger/fix/chained-outputs

Fix chained outputs

Author: luca-moser

output.go

@@ -870,6 +870,30 @@ func SyntacticallyValidateOutputs(outputs Outputs, funcs ...OutputsSyntacticalVa
 	return nil
 }
 
+func OutputsSyntacticalChainConstrainedOutputUniqueness() OutputsSyntacticalValidationFunc {
+	chainConstrainedOutputs := make(ChainConstrainedOutputsSet)
+
+	return func(index int, output Output) error {
+		chainConstrainedOutput, is := output.(ChainConstrainedOutput)
+		if !is {
+			return nil
+		}
+
+		chainID := chainConstrainedOutput.Chain()
+		if chainID.Empty() {
+			// we can ignore newly minted chainConstrainedOutputs
+			return nil
+		}
+
+		if _, has := chainConstrainedOutputs[chainID]; has {
+			return fmt.Errorf("%w: output with chainID %s already exist on the output side", ErrNonUniqueChainConstrainedOutputs, chainID.ToHex())
+		}
+
+		chainConstrainedOutputs[chainID] = chainConstrainedOutput
+		return nil
+	}
+}
+
 // JsonOutputSelector selects the json output implementation for the given type.
 func JsonOutputSelector(ty int) (JSONSerializable, error) {
 	var obj JSONSerializable

protocol_test.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/iotaledger/hive.go/serializer/v2"
@@ -30,19 +29,19 @@ func (test *deSerializeTest) deSerialize(t *testing.T) {
 		require.Error(t, err, test.seriErr)
 		return
 	}
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	if src, ok := test.source.(serializer.SerializableWithSize); ok {
-		assert.Equal(t, len(data), src.Size())
+		require.Equal(t, len(data), src.Size())
 	}
 
 	bytesRead, err := test.target.Deserialize(data, serializer.DeSeriModePerformValidation, tpkg.TestProtoParas)
 	if test.deSeriErr != nil {
 		require.Error(t, err, test.deSeriErr)
 		return
 	}
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	require.Len(t, data, bytesRead)
-	assert.EqualValues(t, test.source, test.target)
+	require.EqualValues(t, test.source, test.target)
 }
 
 func TestProtocolParameters_DeSerialize(t *testing.T) {

transaction_essence.go

@@ -344,6 +344,7 @@ func (u *TransactionEssence) syntacticallyValidate(protoParas *ProtocolParameter
 		OutputsSyntacticalDepositAmount(protoParas),
 		OutputsSyntacticalExpirationAndTimelock(),
 		OutputsSyntacticalNativeTokens(),
+		OutputsSyntacticalChainConstrainedOutputUniqueness(),
 		OutputsSyntacticalFoundry(),
 		OutputsSyntacticalAlias(),
 		OutputsSyntacticalNFT(),

transaction_test.go

@@ -149,6 +149,135 @@ func TestNFTTransition(t *testing.T) {
 	}, inputs))
 }
 
+func TestChainConstrainedOutputUniqueness(t *testing.T) {
+	ident1 := tpkg.RandEd25519Address()
+
+	inputIDs := tpkg.RandOutputIDs(1)
+
+	aliasAddress := iotago.AliasAddressFromOutputID(inputIDs[0])
+	aliasID := aliasAddress.AliasID()
+
+	nftAddress := iotago.NFTAddressFromOutputID(inputIDs[0])
+	nftID := nftAddress.NFTID()
+
+	tests := []deSerializeTest{
+		{
+			// we transition the same Alias twice
+			name: "transition the same Alias twice",
+			source: tpkg.RandTransactionWithEssence(&iotago.TransactionEssence{
+				NetworkID: tpkg.TestNetworkID,
+				Inputs:    inputIDs.UTXOInputs(),
+				Outputs: iotago.Outputs{
+					&iotago.AliasOutput{
+						Amount:  OneMi,
+						AliasID: aliasID,
+						Conditions: iotago.UnlockConditions{
+							&iotago.StateControllerAddressUnlockCondition{Address: ident1},
+							&iotago.GovernorAddressUnlockCondition{Address: ident1},
+						},
+						Features: nil,
+					},
+					&iotago.AliasOutput{
+						Amount:  OneMi,
+						AliasID: aliasID,
+						Conditions: iotago.UnlockConditions{
+							&iotago.StateControllerAddressUnlockCondition{Address: ident1},
+							&iotago.GovernorAddressUnlockCondition{Address: ident1},
+						},
+						Features: nil,
+					},
+				},
+			}),
+			target:    &iotago.Transaction{},
+			seriErr:   iotago.ErrNonUniqueChainConstrainedOutputs,
+			deSeriErr: nil,
+		},
+		{
+			// we transition the same NFT twice
+			name: "transition the same NFT twice",
+			source: tpkg.RandTransactionWithEssence(&iotago.TransactionEssence{
+				NetworkID: tpkg.TestNetworkID,
+				Inputs:    inputIDs.UTXOInputs(),
+				Outputs: iotago.Outputs{
+					&iotago.NFTOutput{
+						Amount: OneMi,
+						NFTID:  nftID,
+						Conditions: iotago.UnlockConditions{
+							&iotago.AddressUnlockCondition{Address: ident1},
+						},
+						Features: nil,
+					},
+					&iotago.NFTOutput{
+						Amount: OneMi,
+						NFTID:  nftID,
+						Conditions: iotago.UnlockConditions{
+							&iotago.AddressUnlockCondition{Address: ident1},
+						},
+						Features: nil,
+					},
+				},
+			}),
+			target:    &iotago.Transaction{},
+			seriErr:   iotago.ErrNonUniqueChainConstrainedOutputs,
+			deSeriErr: nil,
+		},
+		{
+			// we transition the same Foundry twice
+			name: "transition the same Foundry twice",
+			source: tpkg.RandTransactionWithEssence(&iotago.TransactionEssence{
+				NetworkID: tpkg.TestNetworkID,
+				Inputs:    inputIDs.UTXOInputs(),
+				Outputs: iotago.Outputs{
+					&iotago.AliasOutput{
+						Amount:  OneMi,
+						AliasID: aliasID,
+						Conditions: iotago.UnlockConditions{
+							&iotago.StateControllerAddressUnlockCondition{Address: ident1},
+							&iotago.GovernorAddressUnlockCondition{Address: ident1},
+						},
+						Features: nil,
+					},
+					&iotago.FoundryOutput{
+						Amount:       OneMi,
+						NativeTokens: nil,
+						SerialNumber: 1,
+						TokenScheme: &iotago.SimpleTokenScheme{
+							MintedTokens:  big.NewInt(50),
+							MeltedTokens:  big.NewInt(0),
+							MaximumSupply: big.NewInt(50),
+						},
+						Conditions: iotago.UnlockConditions{
+							&iotago.ImmutableAliasUnlockCondition{Address: &aliasAddress},
+						},
+						Features: nil,
+					},
+					&iotago.FoundryOutput{
+						Amount:       OneMi,
+						NativeTokens: nil,
+						SerialNumber: 1,
+						TokenScheme: &iotago.SimpleTokenScheme{
+							MintedTokens:  big.NewInt(50),
+							MeltedTokens:  big.NewInt(0),
+							MaximumSupply: big.NewInt(50),
+						},
+						Conditions: iotago.UnlockConditions{
+							&iotago.ImmutableAliasUnlockCondition{Address: &aliasAddress},
+						},
+						Features: nil,
+					},
+				},
+			}),
+			target:    &iotago.Transaction{},
+			seriErr:   iotago.ErrNonUniqueChainConstrainedOutputs,
+			deSeriErr: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, tt.deSerialize)
+	}
+}
+
 func TestCirculatingSupplyMelting(t *testing.T) {
 	_, ident1, ident1AddrKeys := tpkg.RandEd25519Identity()
 	aliasIdent1 := tpkg.RandAliasAddress()