import timelock utility

Author: noel2004

applications/util/tx.go

@@ -8,6 +8,7 @@ import (
 	"hyperledger.abchain.org/core/crypto"
 	txutil "hyperledger.abchain.org/core/tx"
 	"net/http"
+	"time"
 )
 
 type FabricRPCCore struct {
@@ -36,6 +37,23 @@ func (s *FabricRPCCore) PrehandlePost(rw web.ResponseWriter,
 			s.TxGenerator.BeginTx(nil)
 		}
 
+		if tl := req.PostFormValue("timelock"); tl != "" {
+			td, err := time.ParseDuration(tl)
+			if err != nil {
+				http.Error(rw, err.Error(), http.StatusBadRequest)
+				return
+			}
+			s.TxGenerator.Timelock = time.Now().Add(td)
+
+		} else if tlT := req.PostFormValue("timelockat"); tlT != "" {
+			t, err := time.Parse(time.Stamp, tlT)
+			if err != nil {
+				http.Error(rw, err.Error(), http.StatusBadRequest)
+				return
+			}
+			s.TxGenerator.Timelock = t
+		}
+
 		s.rwForOutput = rw
 	}
 

chaincode/lib/txgen/tx.go

@@ -5,6 +5,7 @@ import (
 	"github.com/golang/protobuf/proto"
 	"hyperledger.abchain.org/chaincode/lib/caller"
 	txutil "hyperledger.abchain.org/core/tx"
+	"time"
 )
 
 type QueryResp struct {
@@ -41,6 +42,7 @@ type TxGenerator struct {
 	calledError   error
 	callnotify    chan struct{}
 	call_deploy   bool
+	Timelock      time.Time
 	Credgenerator TxCredHandler
 	Dispatcher    rpc.Caller
 	MethodMapper  map[string]string
@@ -72,12 +74,28 @@ func (t *TxGenerator) txcall(method string, msg proto.Message) error {
 
 	method = t.methodName(method)
 
-	b, err := txutil.NewTxBuilder(t.Ccname, t.GetNonce(), method, msg)
-	if err != nil {
-		return err
-	}
+	if t.Timelock.IsZero() {
+
+		b, err := txutil.NewTxBuilder(t.Ccname, t.GetNonce(), method, msg)
+		if err != nil {
+			return err
+		}
+		t.txbuilder = b
+
+	} else {
+		b, err := txutil.NewTxBuilderWithTimeLock(t.Ccname, t.GetNonce(), t.Timelock)
+		if err != nil {
+			return err
+		}
 
-	t.txbuilder = b
+		err = b.SetMessage(msg)
+		if err != nil {
+			return err
+		}
+		b.SetMethod(method)
+		t.txbuilder = b
+
+	}
 
 	return nil
 }

chaincode/lib/txhandle/tx.go

@@ -40,6 +40,18 @@ func (cci *ChaincodeTx) TxCall(stub shim.ChaincodeStubInterface,
 		return nil, errors.New("Unmatched chaincode name")
 	}
 
+	//check ts expired
+	if parser.GetFlags().IsTimeLock() {
+		expT := parser.GetTxTime()
+		if expT.IsZero() {
+			return nil, errors.New("Enforced timelock Tx has no valid expired time")
+		} else if nowT, err := stub.GetTxTime(); err != nil {
+			return nil, errors.New("Can not get exec time: " + err.Error())
+		} else if nowT.After(expT) {
+			return nil, errors.New("Tx is expired")
+		}
+	}
+
 	for _, h := range cci.PreHandlers {
 		err := h.PreHandling(stub, function, parser)
 		if err != nil {

core/tx/txParser.go

@@ -8,9 +8,29 @@ import (
 	"time"
 )
 
+type Flags uint32
+
+//indicate the expried time in header is obliged to be considered
+func TxFlag_Timelock() Flags {
+	return Flags(1)
+}
+
+func (f Flags) U() uint32 {
+	return uint32(f)
+}
+
+func (f Flags) And(fanother Flags) Flags {
+	return Flags(uint32(f) | uint32(fanother))
+}
+
+func (f Flags) IsTimeLock() bool {
+	return (f & TxFlag_Timelock()) != 0
+}
+
 type Parser interface {
 	GetCCname() string
 	GetNonce() []byte
+	GetFlags() Flags
 	GetTxTime() time.Time
 	GetAddrCredential() AddrCredentials
 	GetDataCredential() DataCredentials
@@ -35,6 +55,10 @@ func (t *txParser) GetNonce() []byte {
 	return t.nonce
 }
 
+func (t *txParser) GetFlags() Flags {
+	return Flags(t.flags)
+}
+
 func (t *txParser) GetTxTime() time.Time {
 	return t.txts
 }

core/tx/tx_test.go

@@ -38,7 +38,7 @@ func TestTx(t *testing.T) {
 
 	txinit(t)
 
-	msg := &pb.TxMsgExample{[]byte{'1', '9', '8', '4'}, 1984}
+	msg := &pb.TxMsgExample{Param1: []byte{'1', '9', '8', '4'}, Param2: 1984}
 
 	builder, err := NewTxBuilder("gamepai", nil, "example", msg)
 

core/tx/txbuilder.go

@@ -23,7 +23,7 @@ type baseMaker struct {
 	credBuilder *builder
 }
 
-func NewTxMaker(args [][]byte) TxMaker {
+func NewTxMaker(args [][]byte) *baseMaker {
 	return &baseMaker{args, newTxCredentialBuilder()}
 }
 
@@ -79,18 +79,53 @@ type Builder interface {
 
 type baseBuilder struct {
 	baseMaker
-	txHash []byte
+	method string
 	nonce  []byte
+	txHash []byte
 }
 
 func (b *baseBuilder) GetHash() []byte {
+	if b.txHash == nil {
+		b.txHash = b.GenHash(b.method)
+	}
 	return b.txHash
 }
 
 func (b *baseBuilder) GetNonce() []byte {
 	return b.nonce
 }
 
+func (b *baseBuilder) SetHeader(h *pb.TxHeader) error {
+
+	hh := msgToByte(h)
+	if hh == nil {
+		return errors.New("Encode header fail")
+	}
+
+	b.nonce = h.GetNonce()
+	b.txHash = nil
+
+	b.txArgs[0] = hh
+
+	return nil
+}
+
+func (b *baseBuilder) SetMethod(m string) {
+	b.txHash = nil
+	b.method = m
+}
+
+func (b *baseBuilder) SetMessage(msg proto.Message) error {
+
+	hm := msgToByte(msg)
+	if hm == nil {
+		return errors.New("No message binded")
+	}
+	b.txArgs[1] = hm
+	b.txHash = nil
+	return nil
+}
+
 const (
 	queryEffectInHour int = 1
 )
@@ -107,41 +142,71 @@ func GenerateNonce() []byte {
 	return nonce
 }
 
-func NewTxBuilder(ccname string, nonce []byte, method string, msg proto.Message) (Builder, error) {
+func newTxBuilder() *baseBuilder {
 
-	hm := msgToByte(msg)
-	if hm == nil {
-		return nil, errors.New("No message binded")
-	}
+	return &baseBuilder{baseMaker: baseMaker{make([][]byte, 2), newTxCredentialBuilder()}}
+}
+
+func NewTxBuilderWithTimeLock(ccname string, nonce []byte, t time.Time) (b *baseBuilder, err error) {
 
 	if nonce == nil {
 		nonce = GenerateNonce()
 	}
 
-	expTime := &timestamp.Timestamp{
-		Seconds: time.Now().Unix() + int64(queryEffectInHour*3600),
-		Nanos:   0}
+	header := &pb.TxHeader{
+		Base: &pb.TxBase{
+			Network: DefaultNetworkName(),
+			Ccname:  ccname,
+		},
+		ExpiredTs: &timestamp.Timestamp{
+			Seconds: t.Unix(),
+			Nanos:   0},
+		Nonce: nonce,
+		Flags: TxFlag_Timelock().U(),
+	}
+
+	b = newTxBuilder()
+	err = b.SetHeader(header)
+
+	return
+}
+
+func NewTxBuilder2(ccname string, nonce []byte) (b *baseBuilder, err error) {
+
+	if nonce == nil {
+		nonce = GenerateNonce()
+	}
 
 	header := &pb.TxHeader{
 		Base: &pb.TxBase{
 			Network: DefaultNetworkName(),
 			Ccname:  ccname,
-			Method:  "",
 		},
-		ExpiredTs: expTime,
-		Nonce:     nonce,
+		ExpiredTs: &timestamp.Timestamp{
+			Seconds: time.Now().Unix() + int64(queryEffectInHour*3600),
+			Nanos:   0},
+		Nonce: nonce,
 	}
 
-	hh := msgToByte(header)
-	if hh == nil {
-		return nil, errors.New("Encode header fail")
+	b = newTxBuilder()
+	err = b.SetHeader(header)
+
+	return
+}
+
+func NewTxBuilder(ccname string, nonce []byte, method string, msg proto.Message) (*baseBuilder, error) {
+
+	b, err := NewTxBuilder2(ccname, nonce)
+	if err != nil {
+		return nil, err
+	}
+
+	err = b.SetMessage(msg)
+	if err != nil {
+		return nil, err
 	}
 
-	b := &baseBuilder{
-		baseMaker{[][]byte{hh, hm}, newTxCredentialBuilder()},
-		genHash(hh, hm, method),
-		nonce}
+	b.SetMethod(method)
 
 	return b, nil
-
 }