Location-Based Refund Smart Contract with Web3.0

Introduction

Decentralized Location Tracking Application (dApp GPS Tracker) operates on the blockchain network, constituting a decentralized application (dApp). It specializes in tracking user locations, particularly facilitating secure location monitoring between employers and employees.

The essence of the Refund by Location smart contract lies in its utility for scenarios where one party, typically an employer, commits to compensating another party, such as an employee, for their presence within a specified geographic area over a defined period. Through this Ethereum-based smart contract, cryptocurrency payments are automatically triggered upon meeting predetermined conditions, as per the contractual agreement.

In the event of a breach, where the employee's GPS coordinates deviate from the agreed-upon area, the contract state is promptly updated to reflect non-compliance.

Unlike conventional systems where centralized authorities control data, this dApp harnesses the power of blockchain technology to ensure data integrity and user sovereignty. By leveraging blockchain's decentralized nature, data is replicated across multiple nodes, impervious to tampering or deletion. This distributed ledger mechanism not only enhances accessibility but also fortifies security, shielding user data from single-point vulnerabilities.

In contrast to centralized systems susceptible to breaches, where compromised authorities endanger all associated data, the immutable nature of blockchain ensures data integrity and confidentiality. Employing advanced encryption techniques, user data stored on the blockchain remains encrypted, accessible only through authorized decryption, bolstering user privacy and security.

Blockchain

A blockchain is a decentralized, peer-to-peer ledger that accommodates an ever-expanding array of transactions. Each transaction, known as a "block," undergoes cryptographic encryption, receives a timestamp, and is authenticated by all authorized participants of the network through consensus mechanisms, which are predefined rules. If a transaction fails to garner validation from all network members, it is excluded from the ledger. Sequentially, each transaction is linked to its predecessor, forming a chain of blocks. Crucially, transactions are immutable, meaning they cannot be altered or erased once added to the chain. Any modifications necessitate the addition of new transactions to the existing chain, preserving the integrity and transparency of the ledger.

To facilitate a transition from one state to another, a transaction must meet the criteria of validity. Validating a transaction involves a process called mining, where a group of nodes (computers) dedicate their computational resources to create a block containing valid transactions.

Any node in the network can participate as a miner by attempting to create and validate a block. Miners worldwide engage in simultaneous efforts to create and validate blocks. When a miner submits a block to the blockchain, they provide a mathematical "proof," which serves as a guarantee: the existence of this proof verifies the block's validity.

For a block to be appended to the main blockchain, the miner must present their proof faster than any competing miner. This process of validating each block through the presentation of a mathematical proof is referred to as "proof of work."

Accounts

Ethereum's global shared state consists of numerous small entities known as "accounts," which interact through a message-passing system. Each account is associated with a state and a 20-byte address. In Ethereum, an address serves as a 160-bit identifier used to uniquely identify any account.

There are two primary types of accounts:

1. Externally owned accounts (EOAs): These accounts are managed by private keys and do not have any associated code.

2. Contract accounts: These accounts are governed by their contract code and possess associated code functionalities.

...

Ethereum Blockchain

Ethereum stands as a groundbreaking technology empowering the creation of decentralized applications and organizations, facilitating asset management, transactions, and communication without the need for centralized oversight. Unlike traditional systems, Ethereum puts users in control of their data, ensuring transparency and autonomy over shared information. Central to Ethereum's ecosystem is its native cryptocurrency, Ether (ETH), which serves as the currency for various activities within the Ethereum network.

Established in 2015 by visionaries Vitalik Buterin and Gavin Wood, Ethereum has quickly risen to prominence as the second most valuable cryptocurrency globally, trailing only behind Bitcoin. With a market capitalization constituting over 17% of the $1.2 trillion global cryptocurrency market, Ethereum has emerged as a leading force in the digital finance landscape.

In contrast to Bitcoin's primary focus on serving as a digital currency and store of value, Ethereum distinguishes itself by aspiring to be more than just a monetary medium. Rather, Ethereum functions as a decentralized computational network, leveraging blockchain technology to support a myriad of applications and use cases beyond simple transactions.

Wallets

Ethereum wallets serve as gateways to your Ethereum account, providing a seamless interface for account management akin to an Internet banking application, minus the traditional banking institution. With your wallet, you can effortlessly check your balance, initiate transactions, and seamlessly connect with various decentralized applications.

It's important to note that your wallet acts solely as a tool for overseeing your Ethereum account. This means you have the freedom to switch between different wallet providers as you see fit. Many wallets also offer the convenience of managing multiple Ethereum accounts within a single application.

Crucially, wallets do not hold custody of your funds; you retain full ownership and control over your assets. They merely function as facilitators, empowering you to manage what rightfully belongs to you.

Smart Contract.

A smart contract is a program within the Ethereum blockchain. It comprises code and data, residing at a specific address on Ethereum. These contracts act as accounts, executing transactions autonomously. Users interact by triggering predefined functions. Smart contracts enforce rules automatically and are immutable and irreversible by default.

Smart Contract Implementation

Create a wallet at meta-mask

To integrate Metamask into your browser, begin by downloading the appropriate extension for your browser and activating it. Upon activation, access Metamask by clicking on its icon in your browser's top-right corner. If you don't possess an existing account or wish to create a new one, select "Create Wallet" and follow the on-screen instructions to complete the setup process. For detailed guidance on configuration, follow this

Configuring MetaMask Wallet:

1. Install the MetaMask extension on your preferred web browser.

2. Set up your account and select the test network (for this project, the Rinkeby test network is utilized).

3. Load funds into your Rinkeby account address using crypto faucets.

4. Once completed, your wallet will be ready to use.

Utilize Remix IDE to compile, execute, and debug Solidity smart contracts efficiently. Here's a streamlined guide:

1. Open Remix IDE in your browser, create a new file and select Solidity as the environment.

2. Compose your Smart contract in the code section. Click the Compile button in the Compiler window to compile the contract.

3. Execute the code by clicking the Deploy button in the Deploy and Run Transactions window.

4. Post-deployment, access method calls from the deployed contracts dropdown to execute the program. For output, review the console dropdown.

5. For debugging, utilize the Debug button corresponding to the method call in the console. This allows scrutiny of function calls and variable assignments.

pragma solidity ^0.8.20;

contract Project {
    string public latitude = "0.00";
    string public longitude = "0.00";

    function sendCoordinates(string memory _latitude, string memory _longitude) public {
        latitude = _latitude;
        longitude = _longitude;
    }

    function sendMoney(address _receiver, uint _amount) public {
        if (_amount > balances[msg.sender]) {
            revert("Insufficient balance");
        }
    }

    function readCoordinates() public view returns (string memory, string memory) {
        return (latitude, longitude);
    }
}
        

Infura

The mobile application, functioning as a decentralized application (dApp), integrates with the smart contract via the Infura API, serving as a gateway for all interactions with the contract. Accessing the Infura API requires creating an account. Building a project for this application is a prerequisite for viewing request statistics related to the smart contract.

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:http/http.dart';
import 'package:web3dart/web3dart.dart';
import 'package:flutterdapp/Encrypt-Decrypt.dart';
import 'package:flutter_dotenv/flutter_dotenv.dart';

class ParentModel extends ChangeNotifier {
  bool isLoading = true;
  late Client httpClient;
  late String contractAddress;
  late String emp;
  late Web3Client client;
  late DeployedContract contract;
  late ContractFunction readCoordinates;

  Future<void> initiateSetup() async {
    httpClient = Client();
    client = Web3Client(
      "https://mainnet.infura.io/v3/24cd45b6689b4b3183112fd501758f2c",
      httpClient,
    );
    await getEmp();
    await getCredentials();
    await getDeployedContract();
  }

  Future<void> getEmp() async {
    await dotenv.load();
    var contractAddress = dotenv.env['CONTRACT_ADDRESS'];
    if (contractAddress != null) {
      contractAddress = contractAddress;
    } else {
      throw 'Contract address not found in .env file';
    }
  }

  Future<void> getCredentials() async {
    await dotenv.load();
    final privateKey = dotenv.env['PRIVATE_KEY'];
    if (privateKey != null) {
      var credentials = EthPrivateKey.fromHex(privateKey);
    } else {
      throw 'Private key not found in .env file';
    }
  }

  Future<void> getDeployedContract() async {
    contract = DeployedContract(
      ContractAbi.fromJson(emp, "Project"),
      EthereumAddress.fromHex(contractAddress),
    );
    readCoordinates = contract.function("readCoordinates");
  }

  void getCoordinates() async {
    try {
      await initiateSetup();
      final List<dynamic> readCoordinates = await client.call(
        contract: contract,
        function: readCoordinates,
        params: [],
      );

      var x = readCoordinates[0];
      var y = readCoordinates[1];

      if (kDebugMode) {
        print("Data retrieved:");
      }
      if (kDebugMode) {
        print("x: $x");
      }
      if (kDebugMode) {
        print("y: $y");
      }

      var latitude = EncryptionDecryption.decryptAES(x);
      var longitude = EncryptionDecryption.decryptAES(y);

      if (kDebugMode) {
        print("Decrypted coordinates:");
      }
      if (kDebugMode) {
        print("Latitude: $latitude");
      }
      if (kDebugMode) {
        print("Longitude: $longitude");
      }

      isLoading = false;
      notifyListeners();
    } catch (error) {
      if (kDebugMode) {
        print("Error fetching coordinates: $error");
      }
      isLoading = false;
      notifyListeners();
    }
  }
}        

Future Work

The project was finalized promptly, and I'm excited about potential future improvements. One of the planned enhancements is integrating an AI assistant to aid users. Your valuable contributions from the GitHub community are deeply appreciated. Feel free to explore the repository using the provided link. Github

References

• How does Ethereum Work
• Where and how application data is stored in Ethereum
• ETHEREUM VIRTUAL MACHINE (EVM)
• Best Practices for Smart Contract Development
• Getting Deep Into EVM: How Ethereum Works Backstage

#Web3 #SQL #Solidity#TechSkills #CareerDevelopment#MobileDevelopment#.