// Solidity — booking escrow for a hotel stay
// Funds are held until check-in, refundable per policy
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract BookingEscrow {
    enum State { Held, Released, Refunded }

    struct Booking {
        address traveller;
        address supplier;
        uint256 amount;
        uint64  checkIn;
        State   state;
    }

    mapping(bytes32 => Booking) public bookings;

    event Held(bytes32 id, address traveller, uint256 amount);
    event Released(bytes32 id);
    event Refunded(bytes32 id);

    function create(bytes32 id, address supplier, uint64 checkIn)
        external payable
    {
        require(bookings[id].amount == 0, "exists");
        require(msg.value > 0, "no funds");
        bookings[id] = Booking(
            msg.sender, supplier, msg.value, checkIn, State.Held
        );
        emit Held(id, msg.sender, msg.value);
    }

    function release(bytes32 id) external {
        Booking storage b = bookings[id];
        require(msg.sender == b.traveller, "not traveller");
        require(b.state == State.Held, "not held");
        require(block.timestamp >= b.checkIn, "too early");

        b.state = State.Released;
        (bool ok, ) = payable(b.supplier).call{value: b.amount}("");
        require(ok, "send failed");
        emit Released(id);
    }
}

// Solidity — tokenised loyalty points
// Traceable, transferable, and programmable
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract LoyaltyPoints {
    string public name = "SkyMiles On-Chain";
    string public symbol = "SKY";

    mapping(address => uint256) public balanceOf;
    mapping(address => bool)    public isPartner;
    address public admin;

    event Transfer(address indexed from, address indexed to, uint256 v);

    constructor() {
        admin = msg.sender;
    }

    function addPartner(address p) external {
        require(msg.sender == admin, "admin only");
        isPartner[p] = true;
    }

    function mint(address to, uint256 amount) external {
        require(isPartner[msg.sender], "not partner");
        balanceOf[to] += amount;
        emit Transfer(address(0), to, amount);
    }

    function transfer(address to, uint256 amount) external {
        require(balanceOf[msg.sender] >= amount, "balance");
        balanceOf[msg.sender] -= amount;
        balanceOf[to]         += amount;
        emit Transfer(msg.sender, to, amount);
    }

    // In production: add expiry rules, tier checks,
    // partner allowlists, and on-chain redemption logic.
}

# Python — verify a booking on-chain
# (typical work of a backend or analyst on the team)

from web3 import Web3

RPC = "https://sepolia.infura.io/v3/<key>"
CONTRACT = "0xYourContractAddress"
ABI = [
    "function bookings(bytes32) view returns "
    "(address traveller, address supplier, uint256 amount, "
    " uint64 checkIn, uint8 state)"
]

w3 = Web3(Web3.HTTPProvider(RPC))
escrow = w3.eth.contract(address=CONTRACT, abi=ABI)

def status(booking_id_hex: str) -> dict:
    b = escrow.functions.bookings(
        Web3.to_bytes(hexstr=booking_id_hex)
    ).call()

    state_names = ["Held", "Released", "Refunded"]
    return {
        "traveller": b[0],
        "supplier":  b[1],
        "amount_eth": w3.from_wei(b[2], "ether"),
        "check_in":  b[3],
        "state":     state_names[b[4]],
    }

# This lets any supplier or auditor verify the booking
# without trusting a central database.

// Hardhat test — a booking escrow's real edge cases
// These are the scenarios that matter in travel.

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("BookingEscrow", function () {
  let escrow, traveller, supplier;

  beforeEach(async () => {
    [traveller, supplier] = await ethers.getSigners();
    const F = await ethers.getContractFactory("BookingEscrow");
    escrow = await F.deploy();
    await escrow.waitForDeployment();
  });

  it("holds funds at booking time", async () => {
    const id = ethers.id("BK-1001");
    const checkIn = Math.floor(Date.now() / 1000) + 3600;

    await escrow.connect(traveller).create(
      id, supplier.address, checkIn,
      { value: ethers.parseEther("1") }
    );

    const b = await escrow.bookings(id);
    expect(b[2]).to.equal(ethers.parseEther("1"));
    expect(b[4]).to.equal(0); // Held
  });

  it("blocks early release before check-in", async () => {
    const id = ethers.id("BK-1002");
    const checkIn = Math.floor(Date.now() / 1000) + 86400;

    await escrow.connect(traveller).create(
      id, supplier.address, checkIn,
      { value: ethers.parseEther("1") }
    );

    await expect(
      escrow.connect(traveller).release(id)
    ).to.be.revertedWith("too early");
  });
});

// In real projects you also test:
// - Cancellation windows and partial refunds
// - Multi-night stays with per-night pricing
// - Failed sends and fallback logic
// - Time zone and DST edge cases

# Python — reconcile on-chain settlements vs PSP data
# The core job of a blockchain payments engineer in travel.

import pandas as pd
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(RPC))

# 1) Pull on-chain settlement events from last 24h
events = escrow.events.Released.create_filter(
    fromBlock=w3.eth.block_number - 7000
).get_all_entries()

onchain = pd.DataFrame([{
    "booking_id": Web3.to_hex(e["args"]["id"]),
    "amount_eth": w3.from_wei(e["args"].get("amount", 0), "ether"),
    "block":      e["blockNumber"],
    "tx":         e["transactionHash"].hex(),
} for e in events])

# 2) Pull PSP report (Stripe/Adyen/Razorpay export)
psp = pd.read_csv("psp_settlements.csv")

# 3) Match and flag discrepancies
merged = onchain.merge(
    psp, how="outer", on="booking_id", indicator=True
)

missing_onchain = merged[merged["_merge"] == "right_only"]
missing_in_psp  = merged[merged["_merge"] == "left_only"]

print("Missing on-chain:", len(missing_onchain))
print("Missing in PSP:  ", len(missing_in_psp))

# Alerts go to finance and ops — this is where
# blockchain engineering meets real business impact.

Portfolio project — tokenised loyalty + booking
(a single project that shows the full travel use case)

1. Smart contracts
   - Loyalty points ERC-20 style, with partner minting
   - Booking escrow with cancellation policy
   - On-chain redemption: 1000 points = 1 free night

2. Backend
   - Node.js/Express API that reads from chain
   - Simple admin to mint points for a partner
   - Audit log of every event

3. Frontend
   - Small React app: book, cancel, redeem
   - Shows on-chain status and history

4. Deployment
   - Contracts on a testnet (Sepolia / Polygon Amoy)
   - Backend + frontend deployed publicly
   - README with architecture and screenshots

5. Documentation
   - Explain cancellation edge cases handled
   - Show gas cost estimates
   - Note what you would do with a real consortium

This project alone can carry a 30-minute interview
on travel blockchain roles.

6-month roadmap into travel blockchain roles:

Months 1-2:
- Solidity fundamentals + Hardhat/Foundry
- Deploy 2 contracts on a testnet
- Learn ERC-20 and basic security patterns

Months 3-4:
- Build the tokenised loyalty + escrow project
- Add a Node.js API layer and a simple UI
- Write tests covering travel edge cases

Month 5:
- Learn Hyperledger Fabric basics (chaincode)
- Read about travel consortiums and NDC
- Study payments and settlement flows

Month 6:
- Interview prep: contracts, security, domain
- Publish project + write a blog post
- Apply to travel tech and travel fintech teams

Cities hiring in India:
Bengaluru, Mumbai, Gurugram, Hyderabad, Pune.
Remote roles at global travel startups are also common.