Merge pull request #2195 from dedis/warn_signature_2

ClientTransaction version warning

byzcoin/api.go

@@ -168,6 +168,14 @@ func (c *Client) AddTransactionAndWait(tx ClientTransaction, wait int) (*AddTxRe
 		}
 	}
 
+	for _, inst := range tx.Instructions {
+		if inst.version != CurrentVersion {
+			return nil, xerrors.New(
+				"got instruction with wrong version - please use byzcoin." +
+					"NewClientTransaction")
+		}
+	}
+
 	// As we fetch the genesis if required, this will never be
 	// nil but either the genesis or the latest.
 	latest := c.getLatestKnownBlock()

byzcoin/contract_darc_test.go

@@ -32,7 +32,7 @@ func TestSecureDarc(t *testing.T) {
 	invokeEvolve := darc.Action("invoke:" + ContractDarcID + "." + cmdDarcEvolve)
 	invokeEvolveUnrestricted := darc.Action("invoke:" + ContractDarcID + "." + cmdDarcEvolveUnrestriction)
 
-	log.Info("spawn a new secure darc with spawn:insecure_darc - fail")
+	log.Lvl1("spawn a new secure darc with spawn:insecure_darc - fail")
 	secDarc := gDarc.Copy()
 	require.NoError(t, secDarc.Rules.AddRule("spawn:insecure_darc", []byte(restrictedSigner.Identity().String())))
 	secDarcBuf, err := secDarc.ToProto()
@@ -53,7 +53,7 @@ func TestSecureDarc(t *testing.T) {
 	_, err = cl.AddTransactionAndWait(ctx, 10)
 	require.Error(t, err)
 
-	log.Info("do the same but without spawn:insecure_darc - pass")
+	log.Lvl1("do the same but without spawn:insecure_darc - pass")
 	require.NoError(t, secDarc.Rules.DeleteRules("spawn:insecure_darc"))
 	require.NoError(t, secDarc.Rules.UpdateRule(invokeEvolve, []byte(restrictedSigner.Identity().String())))
 	require.NoError(t, secDarc.Rules.UpdateRule(invokeEvolveUnrestricted, []byte(unrestrictedSigner.Identity().String())))
@@ -75,7 +75,7 @@ func TestSecureDarc(t *testing.T) {
 	_, err = cl.AddTransactionAndWait(ctx, 10)
 	require.NoError(t, err)
 
-	log.Info("spawn a darc with a version > 0 - fail")
+	log.Lvl1("spawn a darc with a version > 0 - fail")
 	secDarc.Version = 1
 	secDarcBuf, err = secDarc.ToProto()
 	ctx, err = cl.CreateTransaction(Instruction{
@@ -95,7 +95,7 @@ func TestSecureDarc(t *testing.T) {
 	require.Error(t, err)
 
 	secDarc.Version = 0
-	log.Info("evolve to add rules - fail")
+	log.Lvl1("evolve to add rules - fail")
 	{
 		secDarc2 := secDarc.Copy()
 		require.NoError(t, secDarc2.EvolveFrom(secDarc))
@@ -119,7 +119,7 @@ func TestSecureDarc(t *testing.T) {
 		require.Error(t, err)
 	}
 
-	log.Info("evolve to modify the unrestrict_evolve rule - fail")
+	log.Lvl1("evolve to modify the unrestrict_evolve rule - fail")
 	{
 		secDarc2 := secDarc.Copy()
 		require.NoError(t, secDarc2.EvolveFrom(secDarc))
@@ -146,7 +146,7 @@ func TestSecureDarc(t *testing.T) {
 
 	var barrier *skipchain.SkipBlock
 
-	log.Info("evolve to modify existing rules - pass")
+	log.Lvl1("evolve to modify existing rules - pass")
 	{
 		secDarc2 := secDarc.Copy()
 		require.NoError(t, secDarc2.EvolveFrom(secDarc))
@@ -180,7 +180,7 @@ func TestSecureDarc(t *testing.T) {
 	// should increase by one
 	require.Equal(t, myDarc.Version, gDarc.Version+1)
 
-	log.Info("evolve_unrestricted fails with the wrong signer")
+	log.Lvl1("evolve_unrestricted fails with the wrong signer")
 	{
 		myDarc2 := myDarc.Copy()
 		require.NoError(t, myDarc2.EvolveFrom(&myDarc))
@@ -204,7 +204,7 @@ func TestSecureDarc(t *testing.T) {
 		require.Error(t, err)
 	}
 
-	log.Info("evolve_unrestricted to add rules - pass")
+	log.Lvl1("evolve_unrestricted to add rules - pass")
 	{
 		myDarc2 := myDarc.Copy()
 		require.NoError(t, myDarc2.EvolveFrom(&myDarc))

byzcoin/contracts/coins_test.go

@@ -52,9 +52,6 @@ func TestCoin_Spawn(t *testing.T) {
 		SignerIdentities: []darc.Identity{gsigner.Identity()},
 		SignerCounter:    []uint64{1},
 	}
-	dummyCtxHash := []byte("dummy_ctx_hash")
-	err := inst.SignWith(dummyCtxHash, gsigner)
-	require.Nil(t, err)
 
 	// Spawn cannot use getContract because the instance ID is the genesis darc.
 	// We need a zero contractCoin instead.
@@ -88,10 +85,8 @@ func TestCoin_InvokeMint(t *testing.T) {
 		SignerIdentities: []darc.Identity{gsigner.Identity()},
 		SignerCounter:    []uint64{1},
 	}
-	dummyCtxHash := []byte("dummy_ctx_hash")
-	err := inst.SignWith(dummyCtxHash, gsigner)
-	require.Nil(t, err)
-	_, _, err = ct.getContract(inst.InstanceID).Invoke(ct, inst, []byzcoin.Coin{})
+	_, _, err := ct.getContract(inst.InstanceID).Invoke(ct, inst,
+		[]byzcoin.Coin{})
 	require.Error(t, err)
 
 	inst = byzcoin.Instruction{
@@ -103,8 +98,6 @@ func TestCoin_InvokeMint(t *testing.T) {
 		SignerIdentities: []darc.Identity{gsigner.Identity()},
 		SignerCounter:    []uint64{1},
 	}
-	err = inst.SignWith(dummyCtxHash, gsigner)
-	require.Nil(t, err)
 
 	sc, co, err := ct.getContract(inst.InstanceID).Invoke(ct, inst, []byzcoin.Coin{})
 	require.Nil(t, err)
@@ -136,8 +129,6 @@ func TestCoin_InvokeOverflow(t *testing.T) {
 		SignerIdentities: []darc.Identity{gsigner.Identity()},
 		SignerCounter:    []uint64{1},
 	}
-	dummyCtxHash := []byte("dummy_ctx_hash")
-	require.Nil(t, inst.SignWith(dummyCtxHash, gsigner))
 
 	sc, co, err := ct.getContract(inst.InstanceID).Invoke(ct, inst, []byzcoin.Coin{})
 	require.Error(t, err)
@@ -162,8 +153,6 @@ func TestCoin_InvokeStoreFetch(t *testing.T) {
 		SignerIdentities: []darc.Identity{gsigner.Identity()},
 		SignerCounter:    []uint64{1},
 	}
-	dummyCtxHash := []byte("dummy_ctx_hash")
-	require.Nil(t, inst.SignWith(dummyCtxHash, gsigner))
 
 	c1 := byzcoin.Coin{Name: CoinName, Value: 1}
 	notOlCoin := iid("notOlCoin")
@@ -186,7 +175,6 @@ func TestCoin_InvokeStoreFetch(t *testing.T) {
 		SignerIdentities: []darc.Identity{gsigner.Identity()},
 		SignerCounter:    []uint64{1},
 	}
-	require.Nil(t, inst.SignWith(dummyCtxHash, gsigner))
 
 	// Try once with not enough coins available.
 	sc, co, err = ct.getContract(inst.InstanceID).Invoke(ct, inst, nil)
@@ -232,8 +220,6 @@ func TestCoin_InvokeTransfer(t *testing.T) {
 		SignerCounter:    []uint64{1},
 	}
 
-	dummyCtxHash := []byte("dummy_ctx_hash")
-	require.Nil(t, inst.SignWith(dummyCtxHash, gsigner))
 	sc, co, err := ct.getContract(inst.InstanceID).Invoke(ct, inst, []byzcoin.Coin{})
 	require.Error(t, err)
 
@@ -250,7 +236,6 @@ func TestCoin_InvokeTransfer(t *testing.T) {
 		SignerCounter:    []uint64{1},
 	}
 
-	require.Nil(t, inst.SignWith(dummyCtxHash, gsigner))
 	sc, co, err = ct.getContract(inst.InstanceID).Invoke(ct, inst, []byzcoin.Coin{})
 	require.Nil(t, err)
 	require.Equal(t, 0, len(co))

byzcoin/service_test.go

@@ -363,9 +363,7 @@ func TestService_AddTransaction_ValidInvalid(t *testing.T) {
 	instr2 := createSpawnInstr(s.darc.GetBaseID(), dummyContract, "data", dcID)
 	instr2.SignerIdentities = []darc.Identity{s.signer.Identity()}
 	instr2.SignerCounter = []uint64{3}
-	tx2 := ClientTransaction{
-		Instructions: []Instruction{instr1, instr2},
-	}
+	tx2 := NewClientTransaction(CurrentVersion, instr1, instr2)
 	h := tx2.Instructions.Hash()
 	for i := range tx2.Instructions {
 		err := tx2.Instructions[i].SignWith(h, s.signer)
@@ -390,9 +388,7 @@ func TestService_AddTransaction_ValidInvalid(t *testing.T) {
 	instr2 = createSpawnInstr(s.darc.GetBaseID(), dummyContract, "data", dcID2)
 	instr2.SignerCounter = []uint64{3}
 	instr2.SignerIdentities = []darc.Identity{s.signer.Identity()}
-	tx3 := ClientTransaction{
-		Instructions: []Instruction{instr1, instr2},
-	}
+	tx3 := NewClientTransaction(CurrentVersion, instr1, instr2)
 	tx3.SignWith(s.signer)
 	atx = &AddTxRequest{
 		Version:       CurrentVersion,
@@ -664,18 +660,16 @@ func TestService_DarcProxy(t *testing.T) {
 
 	// now set the signer with the correct callback
 	signer = darc.NewSignerProxy(email, ed.Public, ga)
-	ctx := ClientTransaction{
-		Instructions: []Instruction{
-			{
-				InstanceID: NewInstanceID(d2.GetBaseID()),
-				Spawn: &Spawn{
-					ContractID: "dummy",
-					Args:       Arguments{{Name: "data", Value: []byte("nothing in particular")}},
-				},
-				SignerCounter: []uint64{1},
+	ctx := NewClientTransaction(CurrentVersion,
+		Instruction{
+			InstanceID: NewInstanceID(d2.GetBaseID()),
+			Spawn: &Spawn{
+				ContractID: "dummy",
+				Args:       Arguments{{Name: "data", Value: []byte("nothing in particular")}},
 			},
+			SignerCounter: []uint64{1},
 		},
-	}
+	)
 
 	err = ctx.FillSignersAndSignWith(signer)
 	require.NoError(t, err)
@@ -687,7 +681,6 @@ func TestService_DarcProxy(t *testing.T) {
 		InclusionWait: 10,
 	})
 	transactionOK(t, resp, err)
-	require.NoError(t, err)
 }
 
 func TestService_WrongSigner(t *testing.T) {
@@ -1436,8 +1429,8 @@ func TestService_DarcSpawn(t *testing.T) {
 	require.NoError(t, err)
 	require.True(t, darc2.Equal(darc2Copy))
 
-	ctx := ClientTransaction{
-		Instructions: []Instruction{{
+	ctx := NewClientTransaction(CurrentVersion,
+		Instruction{
 			InstanceID: NewInstanceID(s.darc.GetBaseID()),
 			Spawn: &Spawn{
 				ContractID: ContractDarcID,
@@ -1448,8 +1441,8 @@ func TestService_DarcSpawn(t *testing.T) {
 			},
 			SignerIdentities: []darc.Identity{s.signer.Identity()},
 			SignerCounter:    []uint64{1},
-		}},
-	}
+		},
+	)
 	require.Nil(t, ctx.Instructions[0].SignWith(ctx.Instructions.Hash(), s.signer))
 
 	s.sendTx(t, ctx)

byzcoin/transaction.go

@@ -120,6 +120,8 @@ func (ctx *ClientTransaction) SignWith(signers ...darc.Signer) error {
 
 // NewClientTransaction creates a transaction compatible with the version passed
 // in arguments. Depending on the version, the hash will have a different value.
+// Most common usage is:
+//   byzcoin.NewClientTransaction(byzcoin.CurrentVersion, instr...)
 func NewClientTransaction(v Version, instrs ...Instruction) ClientTransaction {
 	ctx := ClientTransaction{Instructions: instrs}
 	ctx.Instructions.SetVersion(v)
@@ -298,6 +300,10 @@ func (instr *Instruction) SignWith(msg []byte, signers ...darc.Signer) error {
 	if len(signers) != len(instr.SignerCounter) {
 		return xerrors.New("the number of signers does not match the number of counters")
 	}
+	if instr.version != CurrentVersion {
+		return xerrors.New("cannot sign previous versions - please use" +
+			" byzcoin.NewClientTransaction")
+	}
 	instr.Signatures = make([][]byte, len(signers))
 	for i := range signers {
 		signerID := signers[i].Identity()

byzcoin/transaction_test.go

@@ -208,9 +208,7 @@ func combineInstrsAndSign(signer darc.Signer, instrs ...Instruction) (ClientTran
 	for i := range instrs {
 		instrs[i].SignerIdentities = []darc.Identity{signer.Identity()}
 	}
-	t := ClientTransaction{
-		Instructions: instrs,
-	}
+	t := NewClientTransaction(CurrentVersion, instrs...)
 	h := t.Instructions.Hash()
 	for i := range t.Instructions {
 		if err := t.Instructions[i].SignWith(h, signer); err != nil {

calypso/api.go

@@ -66,9 +66,7 @@ func (c *Client) CreateLTS(ltsRoster *onet.Roster, darcID darc.ID, signers []dar
 		},
 		SignerCounter: counters,
 	}
-	tx := byzcoin.ClientTransaction{
-		Instructions: []byzcoin.Instruction{inst},
-	}
+	tx := byzcoin.NewClientTransaction(byzcoin.CurrentVersion, inst)
 	if err := tx.FillSignersAndSignWith(signers...); err != nil {
 		return nil, xerrors.Errorf("signing txn: %v", err)
 	}
@@ -167,17 +165,17 @@ func (c *Client) AddWrite(write *Write, signer darc.Signer, signerCtr uint64,
 	if err != nil {
 		return nil, xerrors.Errorf("encoding Write message: %v", err)
 	}
-	ctx := byzcoin.ClientTransaction{
-		Instructions: byzcoin.Instructions{{
+	ctx := byzcoin.NewClientTransaction(byzcoin.CurrentVersion,
+		byzcoin.Instruction{
 			InstanceID: byzcoin.NewInstanceID(darc.GetBaseID()),
 			Spawn: &byzcoin.Spawn{
 				ContractID: ContractWriteID,
 				Args: byzcoin.Arguments{{
 					Name: "write", Value: writeBuf}},
 			},
 			SignerCounter: []uint64{signerCtr},
-		}},
-	}
+		},
+	)
 	//Sign the transaction
 	err = ctx.FillSignersAndSignWith(signer)
 	if err != nil {
@@ -216,16 +214,16 @@ func (c *Client) AddRead(proof *byzcoin.Proof, signer darc.Signer, signerCtr uin
 		return nil, xerrors.Errorf("encoding Read message: %v", err)
 	}
 
-	ctx := byzcoin.ClientTransaction{
-		Instructions: byzcoin.Instructions{{
+	ctx := byzcoin.NewClientTransaction(byzcoin.CurrentVersion,
+		byzcoin.Instruction{
 			InstanceID: byzcoin.NewInstanceID(proof.InclusionProof.Key()),
 			Spawn: &byzcoin.Spawn{
 				ContractID: ContractReadID,
 				Args:       byzcoin.Arguments{{Name: "read", Value: readBuf}},
 			},
 			SignerCounter: []uint64{signerCtr},
-		}},
-	}
+		},
+	)
 	err = ctx.FillSignersAndSignWith(signer)
 	if err != nil {
 		return nil, xerrors.Errorf("signing txn: %v", err)
@@ -258,8 +256,8 @@ func (c *Client) SpawnDarc(signer darc.Signer, signerCtr uint64,
 		return nil, xerrors.Errorf("serializing darc to protobuf: %v", err)
 	}
 
-	ctx := byzcoin.ClientTransaction{
-		Instructions: []byzcoin.Instruction{{
+	ctx := byzcoin.NewClientTransaction(byzcoin.CurrentVersion,
+		byzcoin.Instruction{
 			InstanceID: byzcoin.NewInstanceID(controlDarc.GetBaseID()),
 			Spawn: &byzcoin.Spawn{
 				ContractID: byzcoin.ContractDarcID,
@@ -269,8 +267,8 @@ func (c *Client) SpawnDarc(signer darc.Signer, signerCtr uint64,
 				}},
 			},
 			SignerCounter: []uint64{signerCtr},
-		}},
-	}
+		},
+	)
 	err = ctx.FillSignersAndSignWith(signer)
 	if err != nil {
 		return nil, xerrors.Errorf("signing txn: %v", err)

calypso/csadmin/clicontracts/lts.go

@@ -79,9 +79,7 @@ func LTSSpawn(c *cli.Context) error {
 		SignerCounter: []uint64{counters.Counters[0] + 1},
 	}
 
-	tx := byzcoin.ClientTransaction{
-		Instructions: []byzcoin.Instruction{inst},
-	}
+	tx := byzcoin.NewClientTransaction(byzcoin.CurrentVersion, inst)
 
 	err = tx.FillSignersAndSignWith(*signer)
 	if err != nil {

calypso/csadmin/clicontracts/read.go

@@ -117,16 +117,16 @@ func ReadSpawn(c *cli.Context) error {
 		return xerrors.Errorf("failed to get the signer counters: %v", err)
 	}
 
-	ctx := byzcoin.ClientTransaction{
-		Instructions: byzcoin.Instructions{{
+	ctx := byzcoin.NewClientTransaction(byzcoin.CurrentVersion,
+		byzcoin.Instruction{
 			InstanceID: byzcoin.NewInstanceID(proof.InclusionProof.Key()),
 			Spawn: &byzcoin.Spawn{
 				ContractID: calypso.ContractReadID,
 				Args:       byzcoin.Arguments{{Name: "read", Value: readBuf}},
 			},
 			SignerCounter: []uint64{counters.Counters[0] + 1},
-		}},
-	}
+		},
+	)
 
 	err = ctx.FillSignersAndSignWith(*signer)
 	if err != nil {