Separated ZK and Service

Signed-off-by: Effi-S <effi.szt@gmail.com>

Author: Effi-S

token/core/zkatdlog/nogh/v1/validator/bench/transfer_service/client/main.go

@@ -2,6 +2,30 @@
 Copyright IBM Corp All Rights Reserved.
 
 SPDX-License-Identifier: Apache-2.0
+
+
+The Flow
+  Client                                  Server
+  ──────                                  ──────
+  1. Load proof data from disk
+     (pub params + token request)
+          │
+  2. JSON-serialize params               3. Receive gRPC request
+     (includes WireProofData)  ──gRPC──►     with name="zkp"
+                                          │
+                                       4. TransferServiceViewFactory.NewView(jsonBytes)
+                                          → deserialize WireProofData → ProofData
+                                          → create token.Validator from public params
+                                          │
+                                       5. TransferServiceView.Call()
+                                          → validator.UnmarshallAndVerifyWithMetadata(...)
+                                            (full pipeline: auditing, signatures, ZK proofs,
+                                             HTLC, upgrade witnesses, metadata checks)
+                                          │
+  6. Receive response            ◄────  7. Return result (nil, nil) on success
+     Record latency/throughput
+
+
 */
 
 package main

token/core/zkatdlog/nogh/v1/validator/bench/transfer_service/out/cmd/test-node/main.go

@@ -8,8 +8,6 @@ package main
 
 import (
 	fscnode "github.com/hyperledger-labs/fabric-smart-client/node"
-
-	
 )
 
 func main() {

token/core/zkatdlog/nogh/v1/validator/bench/transfer_service/transfer_service_bench.go

@@ -7,6 +7,7 @@ SPDX-License-Identifier: Apache-2.0
 package bench
 
 import (
+	"context"
 	"encoding/base64"
 	"encoding/json"
 	"errors"
@@ -17,10 +18,12 @@ import (
 	"strconv"
 	"strings"
 
-	math "github.com/IBM/mathlib"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/view"
-	"github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/transfer"
-	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
+	"github.com/hyperledger-labs/fabric-token-sdk/token"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/core"
+	fabtoken "github.com/hyperledger-labs/fabric-token-sdk/token/core/fabtoken/v1/driver"
+	dlog "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/driver"
+	tk "github.com/hyperledger-labs/fabric-token-sdk/token/token"
 )
 
 const (
@@ -108,43 +111,64 @@ func newTokenTransferVerifyParams(outputPath string,
 	}
 }
 
+type fakeLedger struct{}
+
+func (*fakeLedger) GetState(_ tk.ID) ([]byte, error) {
+	panic("not implemented")
+}
+
+func newTokenValidator(ppRaw []byte) (*token.Validator, error) {
+	is := core.NewPPManagerFactoryService(fabtoken.NewPPMFactory(), dlog.NewPPMFactory())
+	ppm, err := is.PublicParametersFromBytes(ppRaw)
+	if err != nil {
+		return nil, fmt.Errorf("failed to deserialize public parameters: %w", err)
+	}
+	v, err := is.DefaultValidator(ppm)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create default validator: %w", err)
+	}
+	return token.NewValidator(v), nil
+}
+
 type TransferServiceView struct {
-	params trandferServiceParams
-	proof  *ProofData
+	params    trandferServiceParams
+	proof     *ProofData
+	validator *token.Validator
 }
 
-// Call deserializes a token request, extracts its transfer actions,
-// and verifies each ZK proof.
-// To reflect token/core/zkatdlog/nogh/v1/transfer.go VerifyTransfer
+// Call runs the full token request validation pipeline matching the
+// regression test's UnmarshallAndVerifyWithMetadata path: auditing,
+// signatures, ZK proofs, HTLC, upgrade witnesses, and metadata checks.
+// Call Chain:
+//   1. token.Validator.UnmarshallAndVerifyWithMetadata -> driver.Validator.VerifyTokenRequestFromRaw
+//   2. VerifyTokenRequestFromRaw (from token/core/common/validator.go)
+//     - deserializes the raw bytes into a TokenRequest, prepares signed message + signatures
+// 	   - calls VerifyTokenRequest
+//   3. VerifyTokenRequest runs three stages:
+//     - Auditing validation (VerifyAuditing) [verifies auditor signatures]
+//     - Issue validation (verifyIssues) [verifies issue actions]
+//     - Transfer validation (verifyTransfers):
+//       a. TransferActionValidate [action.Validate()]
+//       b. TransferSignatureValidate [verifies sender signatures (deserializes owner identity, checks signature)]
+//       c. TransferUpgradeWitnessValidate
+//       d. TransferZKProofValidate [transfer.NewVerifier(in, outputCommitments, pp).Verify(proof)]
+//       e. TransferHTLCValidate
+//       f. TransferApplicationDataValidate [validates metadata]
+//   4. After all validators pass, it checks that all metadata have been validated
+
 func (q *TransferServiceView) Call(viewCtx view.Context) (interface{}, error) {
 	if q.proof == nil {
 		return nil, errors.New("proof data is nil")
 	}
 
-	tr := &driver.TokenRequest{}
-	if err := tr.FromBytes(q.proof.TokenRequestRaw); err != nil {
-		return nil, fmt.Errorf("failed to deserialize token request: %w", err)
-	}
-
-	pp := q.proof.PubParams
-	for _, raw := range tr.Transfers {
-		action := &transfer.Action{}
-		if err := action.Deserialize(raw); err != nil {
-			return nil, fmt.Errorf("failed to deserialize transfer action: %w", err)
-		}
-		if err := action.Validate(); err != nil {
-			return nil, fmt.Errorf("invalid transfer action: %w", err)
-		}
-
-		inputTokens := action.InputTokens()
-		in := make([]*math.G1, len(inputTokens))
-		for i, tok := range inputTokens {
-			in[i] = tok.Data
-		}
-
-		if err := transfer.NewVerifier(in, action.GetOutputCommitments(), pp).Verify(action.GetProof()); err != nil {
-			return nil, fmt.Errorf("failed to verify transfer proof: %w", err)
-		}
+	_, _, err := q.validator.UnmarshallAndVerifyWithMetadata(
+		context.Background(),
+		&fakeLedger{},
+		token.RequestAnchor(q.proof.TxID),
+		q.proof.TokenRequestRaw,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to verify token request: %w", err)
 	}
 
 	return nil, nil
@@ -160,15 +184,19 @@ func (c *TransferServiceViewFactory) NewView(in []byte) (view.View, error) {
 	if err := json.Unmarshal(in, &f.params); err != nil {
 		return nil, err
 	}
-	var proof *ProofData
 	if f.params.Proof != nil {
-		var err error
-		proof, err = f.params.Proof.Deserialize()
+		proof, err := f.params.Proof.Deserialize()
 		if err != nil {
 			return nil, fmt.Errorf("failed to unmarshal wire proof: %w", err)
 		}
+		f.proof = proof
+
+		v, err := newTokenValidator(f.params.Proof.PubParamsRaw)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create token validator: %w", err)
+		}
+		f.validator = v
 	}
-	f.proof = proof
 
 	return f, nil
 }

token/core/zkatdlog/nogh/v1/validator/bench/transfer_zk_only/api_bench_test.go

@@ -0,0 +1,42 @@
+/*
+Copyright IBM Corp All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+package bench
+
+import (
+	"path"
+	"testing"
+
+	"github.com/hyperledger-labs/fabric-smart-client/integration/benchmark/node"
+	viewregistry "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/view"
+	"github.com/stretchr/testify/require"
+)
+
+func BenchmarkAPI(b *testing.B) {
+	testdataPath := b.TempDir()
+	nodeConfPath := path.Join(testdataPath, "fsc", "nodes", "test-node.0")
+
+	err := node.GenerateConfig(testdataPath)
+	require.NoError(b, err)
+
+	n, err := node.SetupNode(nodeConfPath, node.NamedFactory{
+		Name:    "zkp",
+		Factory: &TransferZKViewFactory{},
+	})
+	require.NoError(b, err)
+	defer n.Stop()
+
+	vm, err := viewregistry.GetManager(n)
+	require.NoError(b, err)
+
+	wl := node.Workload{
+		Name:    "zkp",
+		Factory: &TransferZKViewFactory{},
+		Params:  NewTokenTransferVerifyParamsSlice("")[0],
+	}
+
+	b.ResetTimer()
+	node.RunAPIBenchmark(b, vm, wl)
+}

token/core/zkatdlog/nogh/v1/validator/bench/transfer_zk_only/api_grpc_bench_test.go

@@ -0,0 +1,50 @@
+/*
+Copyright IBM Corp All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package bench
+
+import (
+	"path"
+	"testing"
+
+	"github.com/hyperledger-labs/fabric-smart-client/integration/benchmark/node"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc/benchmark/flags"
+)
+
+var numConn = flags.IntSlice("numConn", []int{1, 2, 4, 8}, "Number of grpc client connections - may be a comma-separated list")
+
+// BenchmarkAPIGRPC exercises the ViewAPI via grpc client.
+// The proof is pre-computed and embedded in the workload params so every
+// gRPC request carries it.
+func BenchmarkAPIGRPC(b *testing.B) {
+	testdataPath := b.TempDir()
+	nodeConfPath := path.Join(testdataPath, "fsc", "nodes", "test-node.0")
+	clientConfPath := path.Join(nodeConfPath, "client-config.yaml")
+
+	err := node.GenerateConfig(testdataPath)
+	require.NoError(b, err)
+
+	n, err := node.SetupNode(nodeConfPath, node.NamedFactory{
+		Name:    "zkp",
+		Factory: &TransferZKViewFactory{},
+	})
+
+	require.NoError(b, err)
+	defer n.Stop()
+
+	wl := node.Workload{
+		Name:    "zkp",
+		Factory: &TransferZKViewFactory{},
+		Params:  NewTokenTransferVerifyParamsSlice("")[0], // TODO
+	}
+
+	node.RunAPIGRPCBenchmark(b, wl, clientConfPath, *numConn)
+
+	// for _, bm := range ... {
+	// 	node.RunAPIGRPPCBenchmark(b, wl, bm)
+	// }
+}

token/core/zkatdlog/nogh/v1/validator/bench/transfer_zk_only/client/main.go

@@ -0,0 +1,60 @@
+/*
+Copyright IBM Corp All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"path"
+	"runtime"
+	"time"
+
+	"github.com/hyperledger-labs/fabric-smart-client/integration/benchmark/node"
+	bench "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/validator/bench/transfer_service"
+	"google.golang.org/grpc/benchmark/flags"
+)
+
+var (
+	numConn      = flags.IntSlice("numConn", []int{1, 2}, "Number of grpc client connections - may be a comma-separated list")
+	numWorker    = flags.IntSlice("cpu", []int{1, 2, 4, 8}, "Number of concurrent worker - may be a comma-separated list")
+	workloadFlag = flags.StringSlice("workloads", []string{"sign"}, "Workloads to execute - may be a comma-separated list")
+	warmupDur    = flag.Duration("warmup", 5*time.Second, "Warmup duration")
+	duration     = flag.Duration("benchtime", 10*time.Second, "Duration for every execution")
+	count        = flag.Int("count", 1, "Number of executions")
+)
+
+func main() {
+	flag.Parse()
+
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	testdataPath := "./out/testdata" // for local debugging you can set testdataPath := "out/testdata"
+	clientConfPath := path.Join(testdataPath, "fsc", "nodes", "test-node.0", "client-config.yaml")
+
+	params := bench.NewTokenTransferVerifyParamsSlice("")[0]
+	fmt.Println("Sending Pre-computing ZK proof...")
+
+	zkpWorkload := node.Workload{
+		Name:    "zkp",
+		Factory: &bench.TransferServiceViewFactory{},
+		Params:  params,
+	}
+
+	selected := make([]node.Workload, 0, len(*workloadFlag))
+	selected = append(selected, zkpWorkload)
+
+	node.RunRemoteBenchmarkSuite(node.RemoteBenchmarkConfig{
+		Workloads:      selected,
+		ClientConfPath: clientConfPath,
+		ConnCounts:     *numConn,
+		WorkerCounts:   *numWorker,
+		WarmupDur:      *warmupDur,
+		BenchTime:      *duration,
+		Count:          *count,
+		BenchName:      "BenchmarkAPIGRPCRemote",
+	})
+}

token/core/zkatdlog/nogh/v1/validator/bench/transfer_zk_only/out/cmd/test-node/main.go

@@ -0,0 +1,18 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package main
+
+import (
+	fscnode "github.com/hyperledger-labs/fabric-smart-client/node"
+)
+
+func main() {
+	n := fscnode.New()
+	n.Execute(func() error {
+		return nil
+	})
+}