Add chord address to signature chain elememt

Signed-off-by: Yilun <[email protected]>

net/node/relay.go

@@ -75,6 +75,7 @@ func (node *node) SendRelayPacket(srcID, srcPubkey, destID, destPubkey, payload,
 		uint32(len(payload)),
 		&payloadHash256,
 		&prevHeaderHash,
+		srcID,
 		srcPubkey,
 		destPubkey,
 		signature,

nknd.go

@@ -120,7 +120,7 @@ func nknMain() error {
 	// if InitLedger return err, ledger.DefaultLedger is uninitialized.
 	defer ledger.DefaultLedger.Store.Close()
 
-	err = por.InitPorServer(account)
+	err = por.InitPorServer(account, ring)
 	if err != nil {
 		return errors.New("PorServer initialization error")
 	}

por/porpackage_test.go

@@ -21,9 +21,10 @@ func TestPorPackage(t *testing.T) {
 	toPk, _ := to.PubKey().EncodePoint(true)
 	relPk, _ := rel.PubKey().EncodePoint(true)
 
+	var srcID []byte
 	dataHash := common.Uint256{}
 	blockHash := common.Uint256{}
-	sc, err := NewSigChain(from, 1, dataHash[:], blockHash[:], toPk, relPk)
+	sc, err := NewSigChain(from, 1, dataHash[:], blockHash[:], srcID, toPk, relPk)
 	if err != nil {
 		t.Error("sigchain created failed")
 	}

por/porserver.go

@@ -8,31 +8,34 @@ import (
 
 	"github.com/nknorg/nkn/common"
 	"github.com/nknorg/nkn/core/transaction"
+	"github.com/nknorg/nkn/net/chord"
 	"github.com/nknorg/nkn/util/log"
 	"github.com/nknorg/nkn/vault"
 )
 
 type PorServer struct {
 	sync.RWMutex
 	account *vault.Account
+	ring    *chord.Ring
 	pors    map[uint32][]*PorPackage
 }
 
 var porServer *PorServer
 
-func NewPorServer(account *vault.Account) *PorServer {
+func NewPorServer(account *vault.Account, ring *chord.Ring) *PorServer {
 	ps := &PorServer{
 		account: account,
+		ring:    ring,
 		pors:    make(map[uint32][]*PorPackage),
 	}
 	return ps
 }
 
-func InitPorServer(account *vault.Account) error {
+func InitPorServer(account *vault.Account, ring *chord.Ring) error {
 	if porServer != nil {
 		return errors.New("PorServer already initialized")
 	}
-	porServer = NewPorServer(account)
+	porServer = NewPorServer(account, ring)
 	return nil
 }
 
@@ -78,16 +81,20 @@ func (ps *PorServer) Verify(sc *SigChain) error {
 }
 
 func (ps *PorServer) CreateSigChain(dataSize uint32, dataHash, blockHash *common.Uint256, destPubkey, nextPubkey []byte) (*SigChain, error) {
-	return NewSigChain(ps.account, dataSize, dataHash[:], blockHash[:], destPubkey, nextPubkey)
+	vnode, err := ps.ring.GetFirstVnode()
+	if err != nil {
+		return nil, err
+	}
+	return NewSigChain(ps.account, dataSize, dataHash[:], blockHash[:], vnode.Id, destPubkey, nextPubkey)
 }
 
-func (ps *PorServer) CreateSigChainForClient(dataSize uint32, dataHash, blockHash *common.Uint256, srcPubkey, destPubkey, signature []byte, sigAlgo SigAlgo) (*SigChain, error) {
+func (ps *PorServer) CreateSigChainForClient(dataSize uint32, dataHash, blockHash *common.Uint256, srcID, srcPubkey, destPubkey, signature []byte, sigAlgo SigAlgo) (*SigChain, error) {
 	pubKey, err := ps.account.PubKey().EncodePoint(true)
 	if err != nil {
 		log.Error("Get account public key error:", err)
 		return nil, err
 	}
-	sigChain, err := NewSigChainWithSignature(dataSize, dataHash[:], blockHash[:], srcPubkey, destPubkey, pubKey, signature, sigAlgo)
+	sigChain, err := NewSigChainWithSignature(dataSize, dataHash[:], blockHash[:], srcID, srcPubkey, destPubkey, pubKey, signature, sigAlgo)
 	if err != nil {
 		log.Error("New signature chain with signature error:", err)
 		return nil, err

por/porserver_test.go

@@ -5,17 +5,19 @@ import (
 
 	"github.com/nknorg/nkn/common"
 	"github.com/nknorg/nkn/crypto"
+	"github.com/nknorg/nkn/net/chord"
 	"github.com/nknorg/nkn/vault"
 )
 
 func TestPorServer(t *testing.T) {
 	crypto.SetAlg("P256R1")
+	ring, _, err := chord.CreateNet()
 	from, _ := vault.NewAccount()
 	rel, _ := vault.NewAccount()
 	to, _ := vault.NewAccount()
-	pmFrom := NewPorServer(from)
-	pmRel := NewPorServer(rel)
-	pmTo := NewPorServer(to)
+	pmFrom := NewPorServer(from, ring)
+	pmRel := NewPorServer(rel, ring)
+	pmTo := NewPorServer(to, ring)
 	toPk, _ := to.PubKey().EncodePoint(true)
 	relPk, _ := rel.PubKey().EncodePoint(true)
 

por/sigchain.go

@@ -25,8 +25,13 @@ import (
 // TODO: move sigAlgo to config.json
 const sigAlgo = SigAlgo_ECDSA
 
-func (sc *SigChainElem) SerializationUnsigned(w io.Writer) error {
-	err := serialization.WriteVarBytes(w, sc.NextPubkey)
+func (sce *SigChainElem) SerializationUnsigned(w io.Writer) error {
+	err := serialization.WriteVarBytes(w, sce.Addr)
+	if err != nil {
+		return err
+	}
+
+	err = serialization.WriteVarBytes(w, sce.NextPubkey)
 	if err != nil {
 		return err
 	}
@@ -78,7 +83,7 @@ func (sc *SigChain) SerializationMetadata(w io.Writer) error {
 	return nil
 }
 
-func NewSigChainWithSignature(dataSize uint32, dataHash, blockHash, srcPubkey, destPubkey, nextPubkey, signature []byte, algo SigAlgo) (*SigChain, error) {
+func NewSigChainWithSignature(dataSize uint32, dataHash, blockHash, srcID, srcPubkey, destPubkey, nextPubkey, signature []byte, algo SigAlgo) (*SigChain, error) {
 	sc := &SigChain{
 		DataSize:   dataSize,
 		DataHash:   dataHash,
@@ -87,8 +92,9 @@ func NewSigChainWithSignature(dataSize uint32, dataHash, blockHash, srcPubkey, d
 		DestPubkey: destPubkey,
 		Elems: []*SigChainElem{
 			&SigChainElem{
-				SigAlgo:    algo,
+				Addr:       srcID,
 				NextPubkey: nextPubkey,
+				SigAlgo:    algo,
 				Signature:  signature,
 			},
 		},
@@ -97,9 +103,8 @@ func NewSigChainWithSignature(dataSize uint32, dataHash, blockHash, srcPubkey, d
 }
 
 // first relay node starts a new signature chain which consists of meta data and the first element.
-func NewSigChain(owner *vault.Account, dataSize uint32, dataHash, blockHash, destPubkey, nextPubkey []byte) (*SigChain, error) {
-	ownPk := owner.PubKey()
-	srcPubkey, err := ownPk.EncodePoint(true)
+func NewSigChain(srcAccount *vault.Account, dataSize uint32, dataHash, blockHash, srcID, destPubkey, nextPubkey []byte) (*SigChain, error) {
+	srcPubkey, err := srcAccount.PubKey().EncodePoint(true)
 	if err != nil {
 		return nil, err
 	}
@@ -112,6 +117,7 @@ func NewSigChain(owner *vault.Account, dataSize uint32, dataHash, blockHash, des
 		DestPubkey: destPubkey,
 		Elems: []*SigChainElem{
 			&SigChainElem{
+				Addr:       srcID,
 				SigAlgo:    sigAlgo,
 				NextPubkey: nextPubkey,
 			},
@@ -135,7 +141,7 @@ func NewSigChain(owner *vault.Account, dataSize uint32, dataHash, blockHash, des
 	}
 
 	hash := sha256.Sum256(buff.Bytes())
-	signature, err := crypto.Sign(owner.PrivKey(), hash[:])
+	signature, err := crypto.Sign(srcAccount.PrivKey(), hash[:])
 	if err != nil {
 		return nil, err
 	}

por/sigchain.proto

@@ -6,9 +6,10 @@ enum SigAlgo {
 }
 
 message SigChainElem {
-  SigAlgo SigAlgo = 1;
+  bytes Addr = 1;
   bytes NextPubkey = 2;
-  bytes Signature = 3;
+  SigAlgo SigAlgo = 3;
+  bytes Signature = 4;
 }
 
 message SigChain {

por/sigchain_test.go

@@ -24,9 +24,10 @@ func TestSigChain(t *testing.T) {
 	relay2Pk, _ := relay2.PubKey().EncodePoint(true)
 
 	// test Sign & Verify
+	var srcID []byte
 	dataHash := common.Uint256{1, 2, 3}
 	blockHash := common.Uint256{4, 5, 6}
-	sc, err := NewSigChain(from, 1, dataHash[:], blockHash[:], toPk, relay1Pk)
+	sc, err := NewSigChain(from, 1, dataHash[:], blockHash[:], srcID, toPk, relay1Pk)
 	if err != nil || sc.Verify() != nil {
 		t.Error("[TestSigChain] 'from' create new SigChain in error")
 	}

rpc/httpjson/interfaces.go

@@ -615,11 +615,12 @@ func sigchaintest(s *RPCServer, params []interface{}) map[string]interface{} {
 	if err != nil {
 		return RpcResultInternalError
 	}
+	srcID := s.node.GetChordAddr()
 	encodedPublickKey, err := account.PubKey().EncodePoint(true)
 	if err != nil {
 		return RpcResultInternalError
 	}
-	sigChain, err := por.NewSigChain(account, 1, dataHash[:], blockHash[:], encodedPublickKey, encodedPublickKey)
+	sigChain, err := por.NewSigChain(account, 1, dataHash[:], blockHash[:], srcID, encodedPublickKey, encodedPublickKey)
 	if err != nil {
 		return RpcResultInternalError
 	}