package main

import (
	"encoding/json"
	"fmt"
	"time"
	"github.com/hyperledger/fabric-chaincode-go/shim"
	"github.com/hyperledger/fabric-protos-go/peer"
)

type BookContract struct {
}

type Book struct {
	ID          string `json:"id"`
	Title       string `json:"title"`
	Author      string `json:"author"`
	PublishedAt string `json:"publishedAt"`
	Genre       string `json:"genre"`
}

func (b *BookContract) Init(APIstub shim.ChaincodeStubInterface) peer.Response {
	return shim.Success(nil)
}

func (b *BookContract) Invoke(APIstub shim.ChaincodeStubInterface) peer.Response {
	function, args := APIstub.GetFunctionAndParameters()

	if function == "AddBook" {
		return b.AddBook(APIstub, args)
	} else if function == "QueryBook" {
		return b.QueryBook(APIstub, args)
	}

	return shim.Error("Invalid function name. Use 'AddBook' or 'QueryBook'.")
}

The provided Go-based smart contract is built for Hyperledger Fabric, designed to manage book records on a blockchain network. This particular smart contract defines the functionality for adding and querying books stored on the blockchain.

At its core, the smart contract has two primary functions: AddBook and QueryBook . The Init function is used to initialize the contract, although in this case, it doesn’t perform any setup tasks. When the contract is invoked, it checks the function name and routes the call to either AddBook or QueryBook
based on the user’s request.
The AddBook function below is responsible for adding new books to the blockchain. It expects four arguments, the contract first generates a timestamp for when the book is being added. It then creates a Book object, which is a Go struct holding all the necessary book details. The contract marshals this structure into a JSON byte array, which is then stored in the ledger using the PutState function. This ensures that the book’s data is securely recorded and can be accessed later.
On the other hand, the QueryBook function below allows users to retrieve information about a specific book by its ID. It queries the blockchain ledger for the corresponding book data. If the book is found, it returns the data; otherwise, it returns an error message indicating that the book is not present in the ledger

func (b *BookContract) AddBook(APIstub shim.ChaincodeStubInterface, args []string) peer.Response {
	if len(args) != 4 {
		return shim.Error("Incorrect number of arguments. Expecting 4: ID, Title, Author, Genre.")
	}
	id := args[0]
	title := args[1]
	author := args[2]
	genre := args[3]
	publishedAt := time.Now().Format(time.RFC3339)

	book := Book{
		ID:          id,
		Title:       title,
		Author:      author,
		PublishedAt: publishedAt,
		Genre:       genre,
	}

	bookAsBytes, err := json.Marshal(book)
	if err != nil {
		return shim.Error(fmt.Sprintf("Failed to marshal book: %v", err))
	}

	err = APIstub.PutState(id, bookAsBytes)
	if err != nil {
		return shim.Error(fmt.Sprintf("Failed to add book to ledger: %v", err))
	}

	return shim.Success([]byte("Book added successfully!"))
}

func (b *BookContract) QueryBook(APIstub shim.ChaincodeStubInterface, args []string) peer.Response {
	if len(args) != 1 {
		return shim.Error("Incorrect number of arguments. Expecting 1: ID.")
	}

	bookAsBytes, err := APIstub.GetState(args[0])
	if err != nil {
		return shim.Error(fmt.Sprintf("Failed to retrieve book: %v", err))
	}

	if bookAsBytes == nil {
		return shim.Error("Book not found.")
	}

	return shim.Success(bookAsBytes)
}

func main() {
	err := shim.Start(new(BookContract))
	if err != nil {
		fmt.Printf("Error starting BookContract: %s", err)
	}
}

The communication with the blockchain network happens through the shim.ChaincodeStubInterface . This interface provides the necessary methods for the smart contract to interact with the blockchain, such as retrieving function parameters, storing data, and returning responses. When a function is called, the contract retrieves the function name and parameters via APIstub.GetFunctionAndParameters() . Based on the function name, it either stores new data using PutState or retrieves data with GetState. The contract uses shim.Success() and shim.Error() to send back appropriate responses to the client, indicating whether the operation was successful or encountered an error.
In summary, this smart contract enables users to interact with a blockchain-based ledger of books. Through API calls, users can add new books or query existing ones by their unique IDs. The contract ensures that all data is securely stored on the blockchain, leveraging the immutable nature of the ledger to maintain a consistent and reliable record of book details.
The chaincode is deployed in the Fabric network using the Fabric CLI commands, ensuring that the contract is correctly instantiated on the network’s peers. For detailed instructions on deploying chaincode, refer to the official Hyperledger Fabric Documentation(Deploy Chaincode).

When working with Hyperledger Fabric, one of the key components in connecting your application to the blockchain network is the connection profile. A connection profile is essentially a JSON file that defines the structure of the Fabric network you are interacting with. It contains details about various components like peers, orderers, certificate authorities (CAs), and the endpoints that your application will use to communicate with the network.
The connection profile serves as a bridge between your client application and the Fabric network. It provides all the necessary configuration to enable secure and efficient interactions.

Creating a correct and accurate connection profile is crucial for ensuring that your client application can securely and seamlessly connect to the blockchain. Without it, your application will not be able to interact with the Fabric network. For connection profile generation you can refer to Hyperledger Fabric (Connection Profile).

Below is an example of what a connection profile might look like. It defines the structure of a Fabric network, specifying details such as peers, orderers, and certificate authorities. This profile is essential for ensuring your application knows how to connect to the network and interact with the blockchain.

{
  "name": "first-network-org3",
  "version": "1.0.0",
  "client": {
    "organization": "Org3",
    "connection": {
      "timeout": {
        "peer": {
          "endorser": "300"
        }
      }
    }
  },
  "organizations": {
    "Org3": {
      "mspid": "Org3MSP",
      "peers": [
        "peer0.org3.example.com"
      ],
      "certificateAuthorities": [
        "ca.org3.example.com"
      ]
    }
  },
  "peers": {
    "peer0.org3.example.com": {
      "url": "grpcs://localhost:11051",
      "tlsCACerts": "${PEERPEM}",
      "grpcOptions": {
        "ssl-target-name-override": "peer0.org3.example.com",
        "hostnameOverride": "peer0.org3.example.com"
      }
    }
  },
  "certificateAuthorities": {
    "ca.org3.example.com": {
      "url": "https://localhost:11054",
      "caName": "ca.org3.example.com",
      "tlsCACerts": "${CAPEM}",
      "httpOptions": {
        "verify": false
      }
    }
  }
}

The $PEERPEM and $CAPEM placeholders should be replaced with the actual peer and CA certificates.

This profile is crucial for enabling your application to connect to the network and interact with the blockchain. As shown in the image above, the JSON structure is meticulously organized to describe the various components of the network and their corresponding configurations. The next step involves using the Fabric SDK in conjunction with the connection profile to establish a secure connection to the blockchain
network.

After the connection profile connection.json is generated which contains the Fabric network’s configuration. This file includes peer and orderer addresses, as well as MSP information.

Before interacting with the Hyperledger Fabric network, you need to register an identity (such as an admin or user) in the wallet. The identity is used to sign transactions and query the chaincode. Below is a step-by-step guide on how to register and store an identity in the wallet.

npm install fabric - ca - client
npm install fabric - network

const { Wallets } = require('fabric-network');
const { FileSystemWallet } = require('fabric-network');
const { FabricCAServices } = require('fabric-ca-client');
const path = require('path');

async function registerIdentity() {
  const caURL = 'http://localhost:11054'; 
  const ca = new FabricCAServices(caURL);
  const wallet = await Wallets.newFileSystemWallet('./wallet');
  
  const userExists = await wallet.get('admin');
  if (userExists) {
    console.log('Identity already exists in wallet');
    return;
  }

  const enrollment = await ca.enroll({
    enrollmentID: 'admin', 
    enrollmentSecret: 'adminpw',
  });

  const identity = {
    credentials: {
      certificate: enrollment.certificate,
      privateKey: enrollment.key.toBytes(),
    },
    mspId: 'Org3MSP', 
    type: 'X.509',
  };

  await wallet.put('admin', identity);
  console.log('Identity registered and added to wallet');
}

By including this identity registration step, you ensure that your application has the proper security and authentication mechanisms in place before interacting with Hyperledger Fabric. The identity is crucial for signing transactions securely and verifying access control on the blockchain network.

Once the identity is registered in the wallet, you can use it for submitting transactions or evaluating queries. The connectToNetwork function (previously shown) already assumes the identity is registered. You can use the ’admin’ identity for signing transactions as follows

const { Gateway, Wallets } = require('fabric-network');
const path = require('path');
const fs = require('fs');

async function connectToNetwork() {
const ccpPath = path.resolve(__dirname, 'connection.json');
const ccp = JSON.parse(fs.readFileSync(ccpPath, 'utf8'));

const wallet = await Wallets.newFileSystemWallet('./wallet');
const gateway = new Gateway();

await gateway.connect(ccp, {
    wallet,
    identity: 'admin',
    discovery: { enabled: true, asLocalhost: true },
});

const network = await gateway.getNetwork('mychannel');
const contract = network.getContract('mychaincode');

return contract;
}

To interact with the smart contract, we’ll implement a simple REST API using Express. This API will expose two endpoints: one for invoking transactions and another for querying data.

app.post('/invoke', async (req, res) => {
try {
    const { functionName, args } = req.body;
    const contract = await connectToNetwork();
    const result = await contract.submitTransaction(functionName, ...args);
    res.json({ message: 'Transaction successful', result: result.toString() });
} catch (error) {
    res.status(500).json({ error: error.message });
}
});

app.get('/query', async (req, res) => {
try {
    const { functionName, args } = req.query;
    const contract = await connectToNetwork();
    const result = await contract.evaluateTransaction(functionName, ...args);
    res.json({ message: 'Query successful', result: result.toString() });
} catch (error) {
    res.status(500).json({ error: error.message });}
});

This Express app provides two main endpoints:

• POST /invoke: This endpoint invokes a transaction on the blockchain. It accepts the function name and arguments in the body of the request.
• GET /query: This endpoint queries the blockchain for data. The function name and arguments are passed as query parameters.

Now, you can test the REST API using tools like Postman or Curl. Below are some sample commands to test the endpoints.

curl -X POST http://localhost:3000/invoke -H "Content-Type: application/json" -d '{"functionName":"AddBook", "args":["Book1", "The Great Adventure", "Tom Cruise", "2025-01-22", "Adventure" ]}'

curl -X GET " http :// localhost :3000/ query ? functionName = QueryBook & args = Book1 "

If everything is set up correctly, you’ll get a response indicating whether the transaction was successful or if the query returned the expected result.