🚧 WIP: Add off-chain-data go client application 🚧

asset-transfer-private-data/application-gateway-go/connect.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2022 IBM All Rights Reserved.
+Copyright 2024 IBM All Rights Reserved.
 
 SPDX-License-Identifier: Apache-2.0
 */
@@ -77,8 +77,8 @@ func newIdentity(certDirectoryPath, mspId string) *identity.X509Identity {
 }
 
 // newSign creates a function that generates a digital signature from a message digest using a private key.
-func newSign(keyDirectoryPash string) identity.Sign {
-	privateKeyPEM, err := readFirstFile(keyDirectoryPash)
+func newSign(keyDirectoryPath string) identity.Sign {
+	privateKeyPEM, err := readFirstFile(keyDirectoryPath)
 	if err != nil {
 		panic(fmt.Errorf("failed to read private key file: %w", err))
 	}

off_chain_data/README.md

@@ -28,7 +28,7 @@ The client application provides several "commands" that can be invoked using the
 
 To keep the sample code concise, the **listen** command writes ledger updates to an output file named `store.log` in the current working directory (which for the Java sample is the `application-java/app` directory). A real implementation could write ledger updates directly to an off-chain data store of choice. You can inspect the information captured in this file as you run the sample.
 
-Note that the **listen** command is is restartable and will resume event listening after the last successfully processed block / transaction. This is achieved using a checkpointer to persist the current listening position. Checkpoint state is persisted to a file named `checkpoint.json` in the current working directory. If no checkpoint state is present, event listening begins from the start of the ledger (block number zero).
+Note that the **listen** command is restartable and will resume event listening after the last successfully processed block / transaction. This is achieved using a checkpointer to persist the current listening position. Checkpoint state is persisted to a file named `checkpoint.json` in the current working directory. If no checkpoint state is present, event listening begins from the start of the ledger (block number zero).
 
 ### Smart Contract
 
@@ -112,4 +112,4 @@ When you are finished, you can bring down the test network (from the `test-netwo
 
 ```
 ./network.sh down
-```
+```

off_chain_data/application-go/app.go

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2024 IBM All Rights Reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+
+	"google.golang.org/grpc"
+)
+
+var allCommands = map[string]func(clientConnection *grpc.ClientConn){
+	"getAllAssets": getAllAssets,
+	"transact":     transact,
+	"listen":       listen,
+}
+
+func main() {
+	commands := os.Args[1:]
+	if len(commands) == 0 {
+		printUsage()
+		panic(errors.New("missing command"))
+	}
+
+	for _, name := range commands {
+		if _, exists := allCommands[name]; !exists {
+			printUsage()
+			panic(fmt.Errorf("unknown command: %s", name))
+		}
+		fmt.Printf("command: %s\n", name)
+	}
+
+	client := newGrpcConnection()
+	defer client.Close()
+
+	for _, name := range commands {
+		command := allCommands[name]
+		command(client)
+	}
+}
+
+func printUsage() {
+	fmt.Println("Arguments: <command1> [<command2> ...]")
+	fmt.Printf("Available commands: %v\n", availableCommands())
+}
+
+func availableCommands() string {
+	result := make([]string, len(allCommands))
+	i := 0
+	for command := range allCommands {
+		result[i] = command
+		i++
+	}
+
+	return strings.Join(result, ", ")
+}

off_chain_data/application-go/blockParser.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"github.com/hyperledger/fabric-gateway/pkg/identity"
+	"github.com/hyperledger/fabric-protos-go-apiv2/common"
+	"github.com/hyperledger/fabric-protos-go-apiv2/ledger/rwset"
+	"github.com/hyperledger/fabric-protos-go-apiv2/ledger/rwset/kvrwset"
+	"github.com/hyperledger/fabric-protos-go-apiv2/peer"
+)
+
+type block interface {
+	getNumber() uint64
+	getTransactions() []transaction
+	toProto() common.Block
+}
+
+type transaction interface {
+	getChannelHeader() common.ChannelHeader
+	getCreator() identity.Identity
+	getValidationCode() uint64
+	isValid() bool
+	getNamespaceReadWriteSets() []namespaceReadWriteSet
+	toProto() common.Payload
+}
+
+type namespaceReadWriteSet interface {
+	getNamespace() string
+	getReadWriteSet() kvrwset.KVRWSet
+	toProto() rwset.NsReadWriteSet
+}
+
+type payload interface {
+	getChannelHeader() common.ChannelHeader
+	getEndorserTransaction() endorserTransaction
+	getSignatureHeader() common.SignatureHeader
+	getTransactionValidationCode() uint64
+	isEndorserTransaction() bool
+	isValid() bool
+	toProto() common.Payload
+}
+
+type endorserTransaction interface {
+	getReadWriteSets() []readWriteSet
+	toProto() peer.Transaction
+}
+
+type readWriteSet interface {
+	getNamespaceReadWriteSets() []namespaceReadWriteSet
+	toProto() rwset.TxReadWriteSet
+}

off_chain_data/application-go/connect.go

@@ -0,0 +1,142 @@
+/*
+ * Copyright 2024 IBM All Rights Reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package main
+
+import (
+	"crypto/x509"
+	"fmt"
+	"os"
+	"path"
+	"time"
+
+	"github.com/hyperledger/fabric-gateway/pkg/client"
+	"github.com/hyperledger/fabric-gateway/pkg/hash"
+	"github.com/hyperledger/fabric-gateway/pkg/identity"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+)
+
+const peerName = "peer0.org1.example.com"
+
+var (
+	channelName   = envOrDefault("CHANNEL_NAME", "mychannel")
+	chaincodeName = envOrDefault("CHAINCODE_NAME", "basic")
+	mspID         = envOrDefault("MSP_ID", "Org1MSP")
+
+	// Path to crypto materials.
+	cryptoPath = envOrDefault("CRYPTO_PATH", "../../test-network/organizations/peerOrganizations/org1.example.com")
+
+	// Path to user private key directory.
+	keyDirectoryPath = envOrDefault("KEY_DIRECTORY_PATH", cryptoPath+"/users/User1@org1.example.com/msp/keystore")
+
+	// Path to user certificate.
+	certPath = envOrDefault("CERT_PATH", cryptoPath+"/users/User1@org1.example.com/msp/signcerts/cert.pem")
+
+	// Path to peer tls certificate.
+	tlsCertPath = envOrDefault("TLS_CERT_PATH", cryptoPath+"/peers/peer0.org1.example.com/tls/ca.crt")
+
+	// Gateway peer endpoint.
+	peerEndpoint = envOrDefault("PEER_ENDPOINT", "dns:///localhost:7051")
+
+	// Gateway peer SSL host name override.
+	peerHostAlias = envOrDefault("PEER_HOST_ALIAS", peerName)
+)
+
+func envOrDefault(key, defaultValue string) string {
+	result := os.Getenv(key)
+	if result == "" {
+		return defaultValue
+	}
+	return result
+}
+
+func newGrpcConnection() *grpc.ClientConn {
+	certificatePEM, err := os.ReadFile(tlsCertPath)
+	if err != nil {
+		panic(fmt.Errorf("failed to read TLS certificate file: %w", err))
+	}
+
+	certificate, err := identity.CertificateFromPEM(certificatePEM)
+	if err != nil {
+		panic(err)
+	}
+
+	certPool := x509.NewCertPool()
+	certPool.AddCert(certificate)
+	transportCredentials := credentials.NewClientTLSFromCert(certPool, peerHostAlias)
+
+	connection, err := grpc.NewClient(peerEndpoint, grpc.WithTransportCredentials(transportCredentials))
+	if err != nil {
+		panic(fmt.Errorf("failed to create gRPC connection: %w", err))
+	}
+
+	return connection
+}
+
+func newConnectOptions(clientConnection *grpc.ClientConn) (identity.Identity, []client.ConnectOption) {
+	return newIdentity(), []client.ConnectOption{
+		client.WithSign(newSign()),
+		client.WithHash(hash.SHA256),
+		client.WithClientConnection(clientConnection),
+		client.WithEvaluateTimeout(5 * time.Second),
+		client.WithEndorseTimeout(15 * time.Second),
+		client.WithSubmitTimeout(5 * time.Second),
+		client.WithCommitStatusTimeout(1 * time.Minute),
+	}
+}
+
+func newIdentity() *identity.X509Identity {
+	certificatePEM, err := os.ReadFile(certPath)
+	if err != nil {
+		panic(fmt.Errorf("failed to read certificate file: %w", err))
+	}
+
+	certificate, err := identity.CertificateFromPEM(certificatePEM)
+	if err != nil {
+		panic(err)
+	}
+
+	id, err := identity.NewX509Identity(mspID, certificate)
+	if err != nil {
+		panic(err)
+	}
+
+	return id
+}
+
+func newSign() identity.Sign {
+	privateKeyPEM, err := readFirstFile(keyDirectoryPath)
+	if err != nil {
+		panic(fmt.Errorf("failed to read private key file: %w", err))
+	}
+
+	privateKey, err := identity.PrivateKeyFromPEM(privateKeyPEM)
+	if err != nil {
+		panic(err)
+	}
+
+	sign, err := identity.NewPrivateKeySign(privateKey)
+	if err != nil {
+		panic(err)
+	}
+
+	return sign
+}
+
+func readFirstFile(dirPath string) ([]byte, error) {
+	dir, err := os.Open(dirPath)
+	if err != nil {
+		return nil, err
+	}
+
+	fileNames, err := dir.Readdirnames(1)
+	if err != nil {
+		return nil, err
+	}
+
+	return os.ReadFile(path.Join(dirPath, fileNames[0]))
+}

off_chain_data/application-go/contract.go

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2024 IBM All Rights Reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package main
+
+import (
+	"strconv"
+
+	"github.com/hyperledger/fabric-gateway/pkg/client"
+)
+
+type asset struct {
+	ID             string
+	Color          string
+	Size           uint64
+	Owner          string
+	AppraisedValue uint64
+}
+
+type assetTransferBasic struct {
+	contract *client.Contract
+}
+
+func newAssetTransferBasic(contract *client.Contract) *assetTransferBasic {
+	return &assetTransferBasic{contract}
+}
+
+func (atb *assetTransferBasic) createAsset(anAsset asset) {
+	if _, err := atb.contract.Submit(
+		"CreateAsset",
+		client.WithArguments(
+			anAsset.ID,
+			anAsset.Color,
+			strconv.FormatUint(anAsset.Size, 10),
+			anAsset.Owner,
+			strconv.FormatUint(anAsset.AppraisedValue, 10),
+		)); err != nil {
+		panic(err)
+	}
+}
+
+func (atb *assetTransferBasic) transferAsset(id, newOwner string) string {
+	result, err := atb.contract.Submit(
+		"TransferAsset",
+		client.WithArguments(
+			id,
+			newOwner,
+		),
+	)
+	if err != nil {
+		panic(err)
+	}
+
+	return string(result)
+}
+
+func (atb *assetTransferBasic) deleteAsset(id string) {
+	if _, err := atb.contract.Submit(
+		"DeleteAsset",
+		client.WithArguments(
+			id,
+		),
+	); err != nil {
+		panic(err)
+	}
+}
+
+func (atb *assetTransferBasic) getAllAssets() []byte {
+	result, err := atb.contract.Evaluate("GetAllAssets")
+	if err != nil {
+		panic(err)
+	}
+	return result
+}