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

contract LoyaltyPoints {
    string  public name   = "Brand Rewards";
    string  public symbol = "BRW";

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

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

    constructor() {
        admin = msg.sender;
    }

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

    // Only approved partners can mint points
    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, "insufficient");
        balanceOf[msg.sender] -= amount;
        balanceOf[to]         += amount;
        emit Transfer(msg.sender, to, amount);
    }

    // In production, also enforce:
    // - Per-partner redemption rules
    // - Expiry and tier checks
    // - Max transfer caps (anti-fraud)
}

// Solidity — escrow for e-commerce orders
// Funds released only after delivery confirmation.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract OrderEscrow {
    enum State { Funded, Delivered, Released, Refunded }

    struct Order {
        address buyer;
        address seller;
        uint256 amount;
        uint64  deliveryDeadline;
        State   state;
    }

    mapping(bytes32 => Order) public orders;

    function fund(
        bytes32 id, address seller, uint64 deadline
    ) external payable {
        require(orders[id].amount == 0, "exists");
        require(msg.value > 0, "no funds");
        orders[id] = Order(
            msg.sender, seller, msg.value, deadline, State.Funded
        );
    }

    function confirmDelivery(bytes32 id) external {
        Order storage o = orders[id];
        require(msg.sender == o.buyer, "not buyer");
        require(o.state == State.Funded, "wrong state");
        o.state = State.Delivered;

        (bool ok, ) = payable(o.seller)
            .call{value: o.amount}("");
        require(ok, "send failed");
        o.state = State.Released;
    }

    function refund(bytes32 id) external {
        Order storage o = orders[id];
        require(block.timestamp > o.deliveryDeadline, "too early");
        require(o.state == State.Funded, "wrong state");

        (bool ok, ) = payable(o.buyer)
            .call{value: o.amount}("");
        require(ok, "refund failed");
        o.state = State.Refunded;
    }
}

# Python — verify a purchase on-chain
# (typical backend work for an e-commerce team)

from web3 import Web3

RPC      = "https://polygon-amoy.g.alchemy.com/v2/<key>"
CONTRACT = "0xYourContractAddress"
ABI = [
    "function orders(bytes32) view returns "
    "(address buyer, address seller, uint256 amount, "
    " uint64 deadline, uint8 state)"
]

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

def status(order_id_hex: str) -> dict:
    raw = escrow.functions.orders(
        Web3.to_bytes(hexstr=order_id_hex)
    ).call()

    states = ["Funded", "Delivered", "Released", "Refunded"]
    return {
        "buyer":       raw[0],
        "seller":      raw[1],
        "amount_eth":  w3.from_wei(raw[2], "ether"),
        "deadline":    raw[3],
        "state":       states[raw[4]],
    }

# Why this matters:
# - Any party (buyer, seller, auditor)
#   can verify the order state without
#   trusting a central database.
# - Disputes resolve in seconds, not days.

Pilot metrics — what to measure first

Loyalty pilot:
- Repeat purchase rate
- Redemption rate (weekly)
- Cross-brand redemptions
- Retention at 30 / 60 / 90 days
- Cost vs traditional loyalty program

Payments pilot:
- Conversion rate (crypto vs card)
- Average order value
- Payment processing cost
- Settlement time (T+0 vs T+2)
- Fraud and chargeback rate

Provenance pilot:
- Dispute rate on verified vs unverified SKUs
- Return rate
- Premium price tolerance
- Time-to-resolve disputes

Rule: pick ONE metric per pilot and
commit to a baseline before launch.
Without a baseline, "success" is
just a feeling.

Phased rollout — how to sequence it

Phase 1 — Foundations (months 1-3)
  - Legal review (token classification, tax)
  - Wallet UX decision (self-custody vs embedded)
  - Chain choice (L2 recommended for cost)
  - Smart contract audit plan
  - Internal team training

Phase 2 — First pilot (months 4-6)
  - Launch ONE use case to a small cohort
  - Loyalty or payments — not both
  - Instrument metrics from day one
  - Weekly reviews with legal and finance

Phase 3 — Scale (months 7-9)
  - Open to broader customer segments
  - Add more reward tiers or payment options
  - Fix what the pilot revealed
  - Budget for ongoing audits

Phase 4 — Ecosystem (months 10-12)
  - Add first partner brand
  - Cross-brand rewards or shared payments
  - Provenance for select SKUs
  - Consider escrow for high-value orders

Key principle: each phase must ship
business value, not just infrastructure.