• Demo link
• Contract Address
• Contract Creator
• Tx Hash of contract creation

In many parts of the world, part-time jobs and freelancing are increasingly common across various sectors, including logistics and parcel delivery.

Let's consider an example to illustrate the problem:

• Person A wants to transfer a parcel from Location A to Location B.
• Currently, Person A has to rely on established logistics companies with fixed service fees, offering no flexibility for negotiation or alternate fee options.
• Delivery partners working for these logistics companies are bound by strict commitments, restricting their ability to take breaks or leave at will.
• Delivery partners cannot set their own fees or choose orders based on convenience, such as picking orders closer to their home at the end of a shift.
• Additionally, logistics companies may store and sell customer data to third parties, increasing the risk of data breaches and personal information misuse.

• Lack of Flexibility in Service Fees: Shippers like Person A cannot negotiate or select different service fees.
• Binding Commitments for Delivery Partners: These commitments limit the flexibility of delivery partners in managing their work schedules.
• Inability to Choose Orders: Delivery partners lack the freedom to select orders based on their preferences or convenience.
• Data Security Concerns: Possibility of data breaches and misuse of personal information.

We propose a blockchain-based solution with an auction system for service requests to address these issues.

• Service Request Creation: The shipper (Person A) creates a service request to transfer a parcel to the recipient (Person B), specifying the service fee they are willing to pay.
• Auction System: Delivery partners can see the service request and participate in a Dutch auction, with bids hidden from each other.
• Driverless NFT: Delivery partners need a Driverless NFT, created from a government-issued ID, to participate.
• Bidding Process: Delivery partners place their bids and stake an insured cargo value equivalent to the item's value.
• Selection and Allocation: The delivery partner with the lowest bid wins and is assigned the service request.
• Delivery and Payment: Upon successful delivery, the delivery partner receives their bid amount, and any unspent portion of the service fee is refunded to the shipper.
• Dispute Resolution: Any disputes are resolved through a voting system involving DAO members.

• Flexibility in Service Fees: Shippers can set their preferred service fees.
• Autonomy for Delivery Partners: They can bid for jobs based on convenience and preferred fees.
• Transparency and Security: Blockchain technology ensures secure and transparent transactions.
• Data Privacy: Reduces the risk of data breaches.
• Verification and Trust: Driverless NFTs ensure that only verified individuals can participate in the delivery process.
• Dispute Resolution: A fair and transparent system is in place for resolving disputes.
• Additional Incentives: Delivery partners earn tokens for successful deliveries, offering additional income opportunities.

• Metamask Wallet: Users need a Metamask wallet to interact with the contract.
• User Roles: Roles include Admin, Shipper, Driver, and Receiver.
• Driving License NFT: Required to apply for the Driver role.
• Blockchain Network: We use the Sepolia network for our contracts.
• User Interface: We have created a webpage with React and Redux for user interactions.

• Role Management: Users can request and approve different roles.
• Service Request Management: Shippers can create and manage service requests.
• Auction System: Drivers can bid on service requests.
• Dispute Resolution: Disputes are handled through DAO voting.
• Reward Mechanism: Drivers receive tokens for completed deliveries.

• We assume users provide accurate location data and timestamps.
• Service fees and cargo insurance values are in ETH.

Do platform Setup!

  enum Role {
    None,
    Admin,
    Shipper,
    Driver,
    Receiver
  }

  enum RequestStatus {
    Pending,
    Approved,
    Rejected
  }

  enum Status {
    DRAFT, // Created by Shipper
    READY_FOR_AUCTION, // Updated by Shipper
    DRIVER_ASSIGNED, // Updated by System
    READY_FOR_PICKUP, // Updated by Shipper
    PARCEL_PICKED_UP, // Updated by Driver
    IN_TRANSIT, // Updated by Driver
    DELIVERED, // Updated by Driver
    CONDITIONALLY_ACCEPTED, // Updated by Receiver
    UNCONDITIONALLY_ACCEPTED, // Updated by Receiver
    CANCELLED, // Updated by Shipper (Only in DRAFT status)
    DISPUTE, // Updated by Receiver
    DISPUTE_RESOLVED // Updated by System
  }

  enum WhomToVote {
    Driver,
    Receiver,
    None
  }

  enum Acceptance {
    CONDITIONAL,
    UNCONDITIONAL
  }

  struct RoleRequest {
    uint256 requestId;
    address applicantUID;
    Role requestedRole;
    RequestStatus requestStatus;
    address approverUID; // Person who approves or rejects the request
  }

  struct User {
    string name;
    address uid;
    string phoneNumberWithISO;
    string serviceGeoHash;
    uint ratingStarsInt;
    string ratingStarsString;
    Role[] role;
  }

  /**
   * @dev For finding out role request info and it's index for updation in User Role Request contract
   */
  struct RoleRequestWithIndexDto {
    RoleRequest roleRequest;
    uint index;
  }

  struct DrivingLicenseInfo {
    string name;
    string id;
    string image;
  }

  struct DriverInfo {
    address driverUID;
    uint256 serviceFee;
    uint256 cargoInsuranceValue;
    bool cargoValueRefunded;
    bool serviceFeeRefunded;
  }

  struct BidInfo {
    address uid;
    uint256 serviceFee;
  }

  /**
   * @dev For Maintaining vote count for Driver & Receiver in case of dispute
   */
  struct VoteCount {
    uint256 driver;
    uint256 receiver;
    uint256 total;
  }

  struct SRInfo {
    uint256 requestId;
    string description;
    address shipperUID;
    address receiverUID;
    string originGeoHash; // Origin geo hash from where parcel has to be picked up
    string destGeoHash; // Destination geo hash from where parcel has to dropped
    uint256 cargoInsurableValue; // Product Value
    uint256 serviceFee; // Delivery charges that shipper is willing to pay
    uint256 requestedPickupTime; // Time at which parcel has to be picket up (In timestamp - seconds)
    uint256 requestedDeliveryTime; // Time at which parcel has to be dropped (In timestamp - seconds)
    uint256 auctionEndTime; // After how many minutes auction should end (Number - minutes)
    address driverUID; // System will update this after auction ends
    Status status;
    string disputeWinner; // empty or DRAW or DRIVER or RECEIVER
    BidInfo bidInfo;
    bool disputeVoteGiven;
  }

  /**
   * @dev For finding out SR info and it's index for updation in Dispute Service Request contract
   */
  struct SRResult {
    Types.SRInfo sr;
    uint256 index;
  }

• Navigate inside the project

  cd logistics-project/blockchain

• Install the dependencies

  npm install

• Update the Metamask Pass phrase in hardhat.config.js file at hardhat.accounts.mnemonic

• Start the hardhat Node

  npm start

• Open new Terminal at same path & Compile the contracts

  npm run compile

• Deploy to localhost/hardhat

  _Note depending on hardhat node port number, you need to change in hardhat config file

  npm run deploy:reset

• Add Hardhat as a network in the Metamask by following this link, You can Navigate to Step-5 in the guide directly.

Meet the amazing team who developed this project.

Suresh Konakanchi 💻 📖 🚧

Anuj Singh 💻 📖 🚧

Pallab Singha 💻 📖 🚧

Arpit Kumar 💻 📖 🚧

Mohamed Farhan S 💻 📖 🚧