Forem: Ankit Sharma

Product Authenticator Using :Stellar Blockchain Technology

Ankit Sharma — Sun, 11 Aug 2024 12:44:26 +0000

This is a submission for the Build Better on Stellar: Smart Contract Challenge : Build a dApp

What I Built

Protecting Medicine Supply Chains with Blockchain:
Our dApp is designed to keep the supply chain safe and transparent, especially in the medical field. Here's how it works:

Verified Supply Chain Steps

Track Every Stage: Every step of a product's journey—from manufacturing to delivery—is recorded on the blockchain.
Immutable Records: Once data is added, it can't be changed, ensuring that the information is reliable and trustworthy.

Preventing Counterfeit Medicines

Stop Fake Products: By verifying each step, we help ensure that only genuine medicines reach the market.
Safeguard Patient Health: This reduces the risk of patients receiving counterfeit or unsafe products.

Empowering Supply Chain Authorities

Real-Time Monitoring: Authorities can monitor the supply chain in real-time, making it easier to spot and address issues.
Enhanced Control: With complete transparency, the entire supply chain can be managed more effectively, ensuring the integrity of the process.

This approach not only protects patients but also strengthens trust in the medical supply chain by using blockchain technology to ensure authenticity and safety.

Demo

The Demo for my project is ==> here :
Click on the above link , their i have given a brief summary of my style of code and all approaches.

My Code

The link for my dapp repo is ==>

https://github.com/Ankitsharma2023/volatile

Journey

Research and Development Process:

Studied Blockchain Solutions: Delved into blockchain technology, focusing on how it can enhance supply chain transparency and security, particularly in the medical field.
Explored Stellar's Capabilities: Focused on the Stellar network, understanding its strengths and how it can be leveraged for secure, immutable tracking of product journeys.
Experimented with Smart Contracts: Built and tested smart contracts on the Stellar testnet to ensure accurate and secure recording of each stage in the production process.
Analyzed Supply Chain Needs: Researched the common pain points in medical supply chains to design a solution that addresses real-world challenges.
Developed a Step-by-Step Approach: Created a methodical plan for developing the dApp, starting from basic tracking features to more complex functionalities, like real-time monitoring.
Crafted and Refined the dApp: Focused on making the application user-friendly while ensuring it meets the stringent security and transparency needs of the medical sector.

Motivation

My primary motivation came from recognizing the critical need to secure the medical supply chain in my region. This inspired me to build a solution that not only tracks the production stages of medicines but also prevents the distribution of counterfeit products, protecting patient health.

Learnings

Through this project, I gained deeper insights into:

Stellar's Blockchain Capabilities: Understanding how Stellar can be utilized for transparent and secure tracking.
Supply Chain Management: Best practices for integrating blockchain into supply chain operations.
Implementing Security in dApps: The importance of safeguarding data and ensuring authenticity in every transaction.
User-Centered Design: The value of creating a solution that is both effective and easy to use for all stakeholders in the supply chain.

Experience with the Ecosystem

Working with Stellar’s ecosystem was a rewarding experience. The platform’s emphasis on security and transparency, combined with its efficiency, made it an ideal choice for developing this dApp. The ability to use smart contracts through Stellar enabled us to create a robust and trustworthy system for tracking medicine production.

Particularly Proud Of

I'm particularly proud of how this dApp simplifies a complex process, making it accessible and beneficial to all involved in the medical supply chain. It not only tackles the issue of counterfeit medicines but also provides a reliable tool for maintaining the integrity of the supply process.

Expand the dApp’s Capabilities: Adding more advanced features like predictive analytics and cross-chain integrations.
Create Educational Content: Developing guides and tutorials to help others understand and build on similar solutions.
Contribute to the Stellar Community: By sharing knowledge and helping other developers, I hope to foster a stronger community around blockchain solutions in the medical sector.
QR Code Scanning: Users can scan the QR code on a product to access its complete history.
A more modern and user friendly UI.

This dApp represents a significant step forward in securing the medical supply chain, and I’m excited to continue building on this foundation.

Video for my application is :-

Additional Prize Categories: Glorious Game and/or Super Sustainable

Product Authenticator Using :Stellar Blockchain Technology

Ankit Sharma — Sun, 11 Aug 2024 12:44:25 +0000

This is a submission for the Build Better on Stellar: Smart Contract Challenge : Build a dApp

What I Built

Protecting Medicine Supply Chains with Blockchain:
Our dApp is designed to keep the supply chain safe and transparent, especially in the medical field. Here's how it works:

Verified Supply Chain Steps

Preventing Counterfeit Medicines

Empowering Supply Chain Authorities

This approach not only protects patients but also strengthens trust in the medical supply chain by using blockchain technology to ensure authenticity and safety.

Demo

The Demo for my project is here :

My Code

The link for my dapp repo is ==>

https://github.com/Ankitsharma2023

Journey

Research and Development Process:

Motivation

Learnings

Through this project, I gained deeper insights into:

Experience with the Ecosystem

Particularly Proud Of

This dApp represents a significant step forward in securing the medical supply chain, and I’m excited to continue building on this foundation.

Additional Prize Categories: Glorious Game and/or Super Sustainable

Product authenticator using :Stellar Blockchain Technology

Ankit Sharma — Sun, 11 Aug 2024 12:23:19 +0000

A) Environment Setup:
Install Rust, using command:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Install the Soroban CLI using below mentioned command.
cargo install --locked soroban-cli
For more info visit => Soroban docs

Install Node.js

Get the Freighter Wallet extension for you browser. Once enabled, then got to the network section and connect your wallet to the testnet.

Install wasm32-unknown-unknown package using command:
rustup target add wasm32-unknown-unknown

To configure your CLI to interact with Testnet, run the following command:

soroban network add \ --global testnet \ --rpc-url https://soroban-testnet.stellar.org:443 \ --network-passphrase "Test SDF Network ; September 2015"

In order to deploy the smartcontract you will need an account. You can either use the an account from theFreighter Walletor can configure an account named alice in the testnet using the command:
soroban keys generate --global alice --network testnet

You can see the public key of account alice:soroban keys address alice

B) Backend (Smart-contract) Setup:

Code for your freighter wallet is as follow :

import {
  requestAccess,
  signTransaction,
  setAllowed,
} from "@stellar/freighter-api";

async function checkConnection() {
  const isAllowed = await setAllowed();
  if (isAllowed) {
    return isAllowed;
  }
}

const retrievePublicKey = async () => {
  let publicKey = "";
  let error = "";
  try {
    publicKey = await requestAccess();
  } catch (e) {
    error = e;
  }
  if (error) {
    return error;
  }
  return publicKey;
};

const userSignTransaction = async (xdr, network, signWith) => {
  let signedTransaction = "";
  let error = "";

  try {
    signedTransaction = await signTransaction(xdr, {
      network,
      accountToSign: signWith,
    });
  } catch (e) {
    error = e;
  }

  if (error) {
    return error;
  }

  return signedTransaction;
};

export { checkConnection, retrievePublicKey, userSignTransaction };

Smart-contract folder Structure:

smart-contract ├── Cargo.lock ├── Cargo.toml ├── README.md └── contracts └── Gate-Pass-Dapp ├── Cargo.toml └── src └── lib.rs

=> Go inside the /smart-contract directory and do the below mentioned steps:

Build the contract:
soroban contract build

Alternte command:

cargo build --target wasm32-unknown-unknown --release

Install Optimizer:

cargo install --locked soroban-cli --features opt

Build an Opmize the contract:

soroban contract optimize --wasm target/wasm32-unknown-unknown/release/Gate_Pass_Dapp.wasm

Steps to the Deploy smart-contract on testnet:

Get the hash of the Wasm bytes, like

4bb69f6355400b2954f9537ec55cd24c4a0a3021eae95758a088b383587657cb

using this command:
soroban contract install --source-account bhupendra --wasm target/wasm32-unknown-unknown/release/Gate_Pass_Dapp.wasm --rpc-url https://soroban-testnet.stellar.org:443 --network-passphrase "Test SDF Network ; September 2015"

By using that Wasm hash, deploy the smartcontract on the testnet and get deployed address of the smartcontract using the following command:

soroban contract deploy \ --wasm-hash 4bb69f6355400b2954f9537ec55cd24c4a0a3021eae95758a088b383587657cb \ --source alice \ --network testnet

Deployed address of this smartcontract:
CBPSRM3TVRYA6PT7ESIXC64QZDTKIQNSKBYJ4CED64CN2OITETB67X2P

*NOTE: If you get the XDR Error error: xdr processing error: xdr value invalid, then follow this article.

The code for Header.js file is as follow:-

import React, { useEffect, useState } from "react";
import { checkConnection, retrievePublicKey } from "./Freighter";
import StellarLogo from "../assets/stellarlogo.png"

const Header = ({setPubKey}) => {
  const [connect, getConnected] = useState("Connect");
  const [publickey, getPublicKey] = useState("");
  const [open, setOpen] = useState(false);

  const handleOpenMenu = () => setOpen(!open);

  useEffect(() => {
    if (publickey !== "") {
      getConnected("Connected!");
      setPubKey(publickey);
    }
  }, [publickey]);

  const connectWallet = async () => {
    if (await checkConnection()) {
      getPublicKey(await retrievePublicKey());
    }
  };

  return (
    <div className="bg-black flex md:flex-row shadow-md justify-between items-center px-10 py-4">
      <div
        className="text-2xl sm:text-3xl lg:text-3xl font-semibold text-white flex items-center gap-5"
      >
        {/* <img src={StellarLogo} alt="CratePass X Stellar" className="w-11" /> */}
        <span className="text-white">Product Authenticator</span>
      </div>

      <div
        onClick={() => handleOpenMenu()}
        className="text-4xl absolute top-4 right-3 md:hidden cursor-pointer text-white"
      >
        <ion-icon name={open ? "close" : "menu"}></ion-icon>
      </div>

      <div>
        <ul
          className={`${
            open ? "top-20 left-0" : "top-[-496px]"
          } flex flex-col md:flex-row md:justify-around items-center text-nowrap md:pb-0 py-3 absolute md:static bg-black md:bg-transparent gap-5 w-full md:w-auto pl-3 md:border-none border-2 border-white rounded-b-2xl transition-all duration-500 ease-in-out z-10`}
        >
          <li>
            <div className="p-1 bg-white border-2 max-w-max rounded-md">
              <span className="p-1 px-2 bg-black text-white h-full rounded-md">
                Address
              </span>
              <span className="px-2 text-black">
                {`${publickey.substring(0, 4)} ${
                  publickey && "..."
                } ${publickey.substring(publickey.length - 4)}`}
              </span>
            </div>
          </li>
          <li>
            <button
              className="text-xl w-52 hover:bg-gray-800 bg-white rounded-md p-4 font-bold text-black border-4 border-white"
              onClick={connectWallet}
            >
              {connect}
            </button>
          </li>
        </ul>
      </div>
    </div>
  );
};

export default Header;

The Soroban file code as follow(without function):-

(1)
import {
  Contract,
  SorobanRpc,
  TransactionBuilder,
  Networks,
  BASE_FEE,
  nativeToScVal,
  Address,
} from "@stellar/stellar-sdk";
import { userSignTransaction } from "../Freighter";

let rpcUrl = "https://soroban-testnet.stellar.org";

let contractAddress =
  "CDHHT6IKGRCFPSYJNKR2JEC3GUHRXGPIDUE2JN4LQLZMTCHYKLB4KZ7D";


const accountToScVal = (account) => new Address(account).toScVal();


const stringToScValString = (value) => {
  return nativeToScVal(value);
};

const numberToU64 = (value) => {
  return nativeToScVal(value, { type: "u64" });
};

let params = {
  fee: BASE_FEE,
  networkPassphrase: Networks.TESTNET,
};

async function contractInt(caller, functName, values) {
  const provider = new SorobanRpc.Server(rpcUrl, { allowHttp: true });
  const sourceAccount = await provider.getAccount(caller);
  const contract = new Contract(contractAddress);
  let buildTx;

  if (values == null) {
    buildTx = new TransactionBuilder(sourceAccount, params)
      .addOperation(contract.call(functName))
      .setTimeout(30)
      .build();
  } else if (Array.isArray(values)) {
    buildTx = new TransactionBuilder(sourceAccount, params)
      .addOperation(contract.call(functName, ...values))
      .setTimeout(30)
      .build();
  } else {
    buildTx = new TransactionBuilder(sourceAccount, params)
      .addOperation(contract.call(functName, values))
      .setTimeout(30)
      .build();
  }

  let _buildTx = await provider.prepareTransaction(buildTx);

  let prepareTx = _buildTx.toXDR(); 

  let signedTx = await userSignTransaction(prepareTx, "TESTNET", caller);

  let tx = TransactionBuilder.fromXDR(signedTx, Networks.TESTNET);

  try {
    let sendTx = await provider.sendTransaction(tx).catch(function (err) {
      console.error("Catch-1", err);
      return err;
    });
    if (sendTx.errorResult) {
      throw new Error("Unable to submit transaction");
    }
    if (sendTx.status === "PENDING") {
      let txResponse = await provider.getTransaction(sendTx.hash);

      while (txResponse.status === "NOT_FOUND") {
        txResponse = await provider.getTransaction(sendTx.hash);
        await new Promise((resolve) => setTimeout(resolve, 100));
      }
      if (txResponse.status === "SUCCESS") {
        let result = txResponse.returnValue;
        return result;
      }
    }
  } catch (err) {
    console.log("Catch-2", err);
    return;
  }
}

.....Integrate it with upcoming code .
Invoke functions from the smart-contract:

To invoke any of the function from the smartcontract you can use this command fromat.

soroban contract invoke \ --id <DEPLOYED_CONTRACT_ADDRESS> \ --source <YOUR_ACCOUNT_NAME> \ --network testnet \ -- \ <FUNCTION_NAME> --<FUNCTION_PARAMETER> <ARGUMENT>

For example:
To status of all registered passes, invoke view_all_pass_status function.

soroban contract invoke \ --id CBPSRM3TVRYA6PT7ESIXC64QZDTKIQNSKBYJ4CED64CN2OITETB67X2P \ --source alice \ --network testnet \ -- \ view_all_pass_status

To create a new pass, invoke create_pass function:

soroban contract invoke \ --id CBPSRM3TVRYA6PT7ESIXC64QZDTKIQNSKBYJ4CED64CN2OITETB67X2P \ --source alice \ --network testnet \ -- \ create_pass --record_id <YOUR_PUBLIC_ADDRESS> --title "Going Home" --descrip "I am going to my home today."

Soroban file code with function:-

(95)
async function createPass(caller, title, descrip) {
  let titleScVal = stringToScValString(title);
  let descripScVal = stringToScValString(descrip);
  let values = [titleScVal, descripScVal];

  try {
    const passId = await contractInt(caller, "create_pass", values);
    let resolvedPassId = Number(passId?._value?._value);
    console.log(resolvedPassId);


    return resolvedPassId;
  } catch (error) {
    console.log("Pass not created. Check if you already have a active pass");
  }
}



async function approvePass(caller, pass_id) {

  let values = numberToU64(pass_id);

  try {
    await contractInt(caller, "approve_pass", values);
    console.log(`!!Pass ID - ${pass_id}, is now Arrpoved!!`);
  } catch (error) {
    console.log("Pass can't be approved!!");
  }
}


async function expirePass(caller, pass_id) {
  let values = numberToU64(pass_id);

  try {
    await contractInt(caller, "expire_pass", values);
    console.log(`!!Pass ID - ${pass_id}, is now expired!!`);
  } catch (error) {
    console.log("Pass can't be expired!!");
  }
}



async function  fetchAllPassStatus(caller) {
  try {
    let result = await contractInt(caller, "view_all_pass_status", null);


    let approvedVal = Number(result?._value[0]?._attributes?.val?._value);


    let expiredVal = Number(result?._value[1]?._attributes?.val?._value);


    let pendingVal = Number(result?._value[2]?._attributes?.val?._value);


    let totalVal = Number(result?._value[3]?._attributes?.val?._value);

    console.log(approvedVal, expiredVal, pendingVal, totalVal);
    let ansArr = [];
    ansArr.push(approvedVal);
    ansArr.push(expiredVal);
    ansArr.push(pendingVal);
    ansArr.push(totalVal);
    return ansArr;
  } catch (error) {
    console.log("Unable to fetch All Pass Status!!");
  }
}


async function fetchMyPassStatus(caller, pass_id) {
  let values = numberToU64(pass_id);
  let result1;
  let result2;

  try {
    result1 = await contractInt(caller, "view_my_pass", values);

  } catch (error) {
    console.log("Unable to fetch Your Pass Status!!");
  }

  try {
    result2 = await contractInt(caller, "view_ac_pass_by_unique_id", values);

  } catch (error) {
    console.log("Unable to fetch Your Pass Status!!");
  }


  let createdTimeVal = Number(result1?._value[0]?._attributes?.val?._value);
  console.log(createdTimeVal);


  let descripVal = result1?._value[1]?._attributes?.val?._value?.toString();
  console.log(descripVal);


  let inTimeVal = Number(result1?._value[2]?._attributes?.val?._value);
  console.log(inTimeVal);


  let isExpiredVal = result1?._value[3]?._attributes?.val?._value;
  console.log(isExpiredVal);


  let titleVal = result1?._value[4]?._attributes?.val?._value?.toString();
  console.log(titleVal);


  let passIdVal = Number(result1?._value[5]?._attributes?.val?._value);
  console.log(passIdVal);


  let approvalStatusVal = result2?._value[1]?._attributes?.val?._value;
  console.log(approvalStatusVal);


  let outTimeVal = Number(result2?._value[2]?._attributes?.val?._value);
  console.log(outTimeVal);


  let ansArr = [];
  ansArr.push(createdTimeVal);
  ansArr.push(descripVal);
  ansArr.push(inTimeVal);
  ansArr.push(isExpiredVal);
  ansArr.push(titleVal);
  ansArr.push(passIdVal);
  ansArr.push(approvalStatusVal);
  ansArr.push(outTimeVal);

  return ansArr;
}




export {
  createPass,
  approvePass,
  expirePass,
  fetchAllPassStatus,
  fetchMyPassStatus,
};

The App.js file is as follow;-

import "./App.css";
import Header from "./components/Header";
import Admin from "./components/Admin/Admin";
import RegularUser from "./components/RegularUser/RegularUser";
import { createContext, useState } from "react";
import { ADMIN_KEY } from "./constants/constants";

const pubKeyData = createContext();
const passIdContext = createContext();

function App() {
  const [pubkey, _setPubKey] = useState("");
  const [passId, _setPassId] = useState();

  return (
    <div className="App">
      <pubKeyData.Provider value={pubkey}>
        <Header setPubKey={_setPubKey} />

          <passIdContext.Provider value={{passId, _setPassId}}>
            <RegularUser />
            {pubkey.toString() === ADMIN_KEY && <Admin />}
          </passIdContext.Provider>
      </pubKeyData.Provider>
    </div>
  );
}

export default App;
export { pubKeyData, passIdContext };

The more about my code you can reach to my github repo:-

https://github.com/Ankitsharma2023/volatile