semfnode 1.0.0__tar.gz → 1.1.0__tar.gz

{semfnode-1.0.0 → semfnode-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: semfnode
-Version: 1.0.0
+Version: 1.1.0
 Summary: Kelp harvest scheduling utilities for coastal tide pools
 Author: M. Holloway
 License-Expression: MIT
@@ -16,4 +16,3 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Oceanography
 Requires-Python: >=3.8
-Description-Content-Type: text/markdown

{semfnode-1.0.0 → semfnode-1.1.0}/pyproject.toml

@@ -4,9 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "semfnode"
-version = "1.0.0"
+version = "1.1.0"
 description = "Kelp harvest scheduling utilities for coastal tide pools"
-readme = "README.md"
 license = "MIT"
 requires-python = ">=3.8"
 authors = [

semfnode-1.1.0/src/bc/__init__.py

@@ -0,0 +1,723 @@
+"""
+Blockchain Practicals — lab code bank.
+
+Usage:
+    import bc
+    bc.prac1()   # prints Practical 1 code
+    bc.prac10()  # prints Practical 10 code
+"""
+
+__version__ = "1.0.0"
+
+
+def _show(code: str) -> str:
+    print(code)
+    return code
+
+
+def prac1():
+    return _show('''# Practical No. 1
+# Aim: Installation of Ethereum, Truffle, Ganache, and other tools
+
+# ------------------------------------------------------------
+# SETUP / INSTALLATION STEPS
+# ------------------------------------------------------------
+
+# Step 1: Install Node.js and npm (required to run Truffle)
+#   Download the LTS installer from: https://nodejs.org/en/download
+#   Windows/Mac: run the installer and follow the prompts.
+#   Linux (Debian/Ubuntu):
+    curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
+    sudo apt-get install -y nodejs
+#   Verify installation:
+    node -v
+    npm -v
+
+# Step 2: Install Truffle globally via npm
+    npm install -g truffle
+#   Verify installation:
+    truffle version
+
+# Step 3: Install Ganache (local Ethereum blockchain for testing)
+#   Option A - GUI app (recommended for beginners):
+#     Download from: https://trufflesuite.com/ganache/
+#   Option B - CLI version via npm:
+    npm install -g ganache
+#   Verify installation:
+    ganache --version
+
+# Step 4: Install MetaMask (browser wallet to interact with contracts)
+#   Install the browser extension from: https://metamask.io/download/
+#   Available for Chrome, Firefox, Brave, and Edge.
+
+# Step 5: Use Remix IDE (no installation needed)
+#   Open in any browser: https://remix.ethereum.org
+#   Used to write, compile, and deploy Solidity smart contracts directly.
+
+# Step 6 (optional): VS Code + Solidity extension for local editing
+#   Download VS Code: https://code.visualstudio.com/
+#   Install the "Solidity" extension (by Juan Blanco) from the Extensions marketplace.
+
+# ------------------------------------------------------------
+# THEORY
+# ------------------------------------------------------------
+# Ethereum development requires a set of core tools:
+#   - Node.js & npm: JavaScript runtime and package manager needed to run Truffle
+#   - Truffle: a development framework for compiling, testing, and deploying smart contracts
+#   - Ganache: a personal Ethereum blockchain for local testing, with test accounts pre-funded
+#     with fake ETH
+#   - MetaMask/Remix: browser tools to interact with contracts and wallets
+# Once installed, these tools together provide a complete local blockchain
+# development environment.
+
+# ------------------------------------------------------------
+# OUTPUT
+# ------------------------------------------------------------
+# node -v / npm -v          -> prints installed versions
+# truffle version           -> prints Truffle, Solidity, Node, Web3.js versions
+# ganache --version         -> prints Ganache CLI version
+# Ganache running           -> lists 10 test accounts, each pre-loaded with 100 ETH
+''')
+
+def prac2():
+    return _show('''# Practical No. 2
+# Aim: Writing and Deploying Basic Smart Contracts on Ethereum
+
+# ------------------------------------------------------------
+# SETUP STEPS (uses Remix IDE - no local installation required)
+# ------------------------------------------------------------
+# Step 1: Open https://remix.ethereum.org in your browser
+# Step 2: In the File Explorer, create a new file named "AddTwoNumbers.sol"
+# Step 3: Paste the Solidity code below into the file
+# Step 4: Go to the "Solidity Compiler" tab (left sidebar) and click "Compile AddTwoNumbers.sol"
+# Step 5: Go to the "Deploy & Run Transactions" tab
+#         - Set ENVIRONMENT to "Remix VM (London)" (an in-browser test blockchain)
+#         - Click "Deploy"
+# Step 6: Under "Deployed Contracts", expand the contract and call add(5, 3)
+
+# ------------------------------------------------------------
+# THEORY
+# ------------------------------------------------------------
+# Smart contracts are self-executing programs stored on the blockchain that
+# automatically enforce the terms of an agreement.
+# Key features:
+#   - Run on the Ethereum Virtual Machine (EVM)
+#   - Immutable once deployed
+#   - Transparent and verifiable by anyone on the network
+#   - Execute automatically without intermediaries
+
+# ------------------------------------------------------------
+# CODE (Solidity)
+# ------------------------------------------------------------
+CONTRACT_CODE = """
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.8.2 <0.9.0;
+
+contract AddTwoNumbers {
+    // Function to add two numbers and return the result
+    function add(uint256 a, uint256 b) public pure returns (uint256) {
+        return a + b;
+    }
+}
+"""
+
+# ------------------------------------------------------------
+# OUTPUT
+# ------------------------------------------------------------
+# The contract compiles and deploys successfully in Remix IDE.
+# Calling add(5, 3) returns: 8
+''')
+
+def prac3():
+    return _show('''# Practical No. 3
+# Aim: Configuring and Running a Hyperledger Fabric Network
+
+# ------------------------------------------------------------
+# SETUP / INSTALLATION STEPS (Windows users go through WSL first)
+# ------------------------------------------------------------
+
+# Step 1: Enable WSL2 on Windows (skip if using native Linux/Mac)
+#   Open PowerShell as Administrator and run:
+    wsl --install
+#   This installs WSL2 and Ubuntu by default. Restart your machine when prompted.
+#   Reference: https://learn.microsoft.com/en-us/windows/wsl/install
+#   If WSL is already installed, make sure it is on version 2:
+    wsl --set-default-version 2
+#   To install a specific Ubuntu version:
+    wsl --install -d Ubuntu-22.04
+
+# Step 2: Install Docker Desktop
+#   Download from: https://www.docker.com/products/docker-desktop/
+#   During/after install, open Docker Desktop -> Settings -> Resources -> WSL Integration
+#   and enable integration with your Ubuntu distro. Docker Compose ships bundled with it.
+#   Verify inside the Ubuntu (WSL) terminal:
+    docker --version
+    docker compose version
+
+# Step 3: Update packages and install prerequisites inside Ubuntu/WSL
+    sudo apt-get update
+    sudo apt-get install -y curl git build-essential
+
+# Step 4: Install Go (required by some Fabric components)
+#   Download the Linux tarball from: https://go.dev/dl/
+    wget https://go.dev/dl/go1.21.0.linux-amd64.tar.gz
+    sudo tar -C /usr/local -xzf go1.21.0.linux-amd64.tar.gz
+    echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
+    source ~/.bashrc
+    go version
+
+# Step 5: Install Node.js and npm inside Ubuntu/WSL
+    curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
+    sudo apt-get install -y nodejs
+    node -v
+
+# Step 6: Install Java (default-jdk) - needed for Java chaincode/tests
+    sudo apt-get install -y default-jdk
+    java -version
+
+# Step 7: Download Hyperledger Fabric binaries, Docker images, and samples
+#   Official bootstrap script (installs fabric-samples, binaries, and docker images):
+    curl -sSLO https://raw.githubusercontent.com/hyperledger/fabric/main/scripts/bootstrap.sh
+    chmod +x bootstrap.sh
+    ./bootstrap.sh
+#   This creates a "fabric-samples" folder containing "test-network", "fabcar", etc.
+
+# Step 8: Bring up the test network
+    cd fabric-samples/test-network
+    ./network.sh up
+
+# Step 9: Create a channel between organizations
+    ./network.sh createChannel
+
+# Step 10: Tear the network down when done
+    ./network.sh down
+
+# ------------------------------------------------------------
+# THEORY
+# ------------------------------------------------------------
+# Hyperledger Fabric is a permissioned blockchain framework designed for
+# enterprise use, supporting private channels and pluggable consensus.
+# The fabric-samples/test-network directory provides a script, network.sh,
+# to bring the network up, create channels, and tear it down.
+
+# ------------------------------------------------------------
+# OUTPUT
+# ------------------------------------------------------------
+# The network starts successfully with peer and orderer containers running,
+# and a channel is created between the organizations.
+# Run "docker ps" to confirm containers such as peer0.org1.example.com,
+# peer0.org2.example.com, and orderer.example.com are up.
+''')
+
+def prac4():
+    return _show('''# Practical No. 4
+# Aim: Storing and Retrieving Data Using IPFS
+
+# ------------------------------------------------------------
+# SETUP / INSTALLATION STEPS
+# ------------------------------------------------------------
+
+# Step 1: Download go-ipfs (Kubo) for your platform
+#   Get the latest release list from: https://dist.ipfs.tech/#go-ipfs
+#   Example for Linux amd64:
+    wget https://dist.ipfs.io/go-ipfs/v0.21.0/go-ipfs_v0.21.0_linux-amd64.tar.gz
+
+# Step 2: Extract the archive
+    tar -xvzf go-ipfs_v0.21.0_linux-amd64.tar.gz
+    cd go-ipfs
+
+# Step 3: Run the install script (copies the ipfs binary to /usr/local/bin)
+    sudo bash install.sh
+
+# Step 4: Verify installation
+    ipfs --version
+
+# Step 5: Initialize the local IPFS repository (one-time setup)
+    ipfs init
+
+# Step 6: Start the IPFS daemon (keep this running in its own terminal)
+    ipfs daemon
+
+# Step 7: In a new terminal, create and store a file on IPFS
+    echo "This is an example file to store on IPFS." > example.txt
+    ipfs add example.txt
+
+# Step 8: Retrieve the file using its returned content hash (CID)
+    ipfs cat <CID_FROM_STEP_7>
+
+# ------------------------------------------------------------
+# THEORY
+# ------------------------------------------------------------
+# IPFS is a peer-to-peer distributed file system that stores data using
+# content-based addressing instead of location-based addressing.
+# Each file is identified by a unique cryptographic hash (CID), and any
+# change to the file content produces a new hash.
+# Core commands:
+#   - ipfs init         : initializes the local IPFS repository
+#   - ipfs daemon       : starts the IPFS node
+#   - ipfs add <file>   : uploads a file and returns its content hash
+# This makes IPFS useful for tamper-proof, decentralized storage that can
+# be referenced from blockchain smart contracts.
+
+# ------------------------------------------------------------
+# OUTPUT
+# ------------------------------------------------------------
+# added QmXo9...k3F4 example.txt
+# The returned hash (CID) can be used to retrieve the file from any IPFS node.
+''')
+
+def prac5():
+    return _show('''# Practical No. 5
+# Aim: Using Blockchain to Ensure Data Integrity in ML Models
+
+# ------------------------------------------------------------
+# SETUP STEPS (uses Remix IDE - same environment as Practical 2)
+# ------------------------------------------------------------
+# Step 1: Open https://remix.ethereum.org
+# Step 2: Create a new file "MLDataRegistry.sol" and paste the code below
+# Step 3: Compile it in the "Solidity Compiler" tab
+# Step 4: Deploy it under "Deploy & Run Transactions" using Remix VM
+# Step 5: Call uploadDataset(<hash>) first, then registerModel(...), then getDataset(<hash>)
+
+# ------------------------------------------------------------
+# THEORY
+# ------------------------------------------------------------
+# The goal is to make ML models and their training data tamper-proof,
+# transparent, and auditable by:
+#   - Ensuring training data has not been tampered with
+#   - Verifying model provenance: who trained it, when, and on what data
+#   - Making predictions auditable and traceable
+# This is achieved by storing cryptographic hashes of datasets and models
+# on-chain, rather than the raw data itself, keeping storage costs low
+# while preserving verifiability.
+
+# ------------------------------------------------------------
+# CODE (Solidity)
+# ------------------------------------------------------------
+CONTRACT_CODE = """
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.8.2 <0.9.0;
+
+contract MLDataRegistry {
+    struct Dataset {
+        string dataHash;
+        address uploader;
+        uint timestamp;
+    }
+
+    struct MLModel {
+        string modelHash;
+        string dataHash;
+        string metrics;
+        address trainer;
+        uint timestamp;
+    }
+
+    mapping(string => Dataset) public datasets;
+    mapping(string => MLModel) public models;
+
+    event DatasetUploaded(string dataHash, address uploader, uint timestamp);
+    event ModelTrained(string modelHash, string dataHash, string metrics, address trainer, uint timestamp);
+
+    function uploadDataset(string memory _dataHash) public {
+        require(bytes(_dataHash).length > 0, "Invalid hash");
+        datasets[_dataHash] = Dataset(_dataHash, msg.sender, block.timestamp);
+        emit DatasetUploaded(_dataHash, msg.sender, block.timestamp);
+    }
+
+    function registerModel(string memory _modelHash, string memory _dataHash, string memory _metrics) public {
+        require(datasets[_dataHash].timestamp != 0, "Dataset must be uploaded first");
+        models[_modelHash] = MLModel(_modelHash, _dataHash, _metrics, msg.sender, block.timestamp);
+        emit ModelTrained(_modelHash, _dataHash, _metrics, msg.sender, block.timestamp);
+    }
+
+    function getDataset(string memory _dataHash) public view returns (Dataset memory) {
+        return datasets[_dataHash];
+    }
+}
+"""
+
+# ------------------------------------------------------------
+# OUTPUT
+# ------------------------------------------------------------
+# uploadDataset("9a0364b9e99bb...c9fefb0")
+# getDataset("9a0364b9e99bb...c9fefb0") returns:
+# {
+#   "dataHash": "9a0364b9e99bb...c9fefb0",
+#   "uploader": "0xAbC1234...7890",
+#   "timestamp": 1717420217
+# }
+''')
+
+def prac6():
+    return _show('''# Practical No. 6
+# Aim: Implementing a Blockchain-Based Data Provenance System
+
+# ------------------------------------------------------------
+# SETUP STEPS (uses Remix IDE - same environment as Practical 2)
+# ------------------------------------------------------------
+# Step 1: Open https://remix.ethereum.org
+# Step 2: Create "DataProvenance.sol" and paste the code below
+# Step 3: Compile, then deploy using Remix VM
+# Step 4: Call logData("file1", "<hash>") one or more times
+# Step 5: Call getProvenance("file1") to view the full history
+
+# ------------------------------------------------------------
+# THEORY
+# ------------------------------------------------------------
+# Data provenance refers to tracking the origin and history of a piece of
+# data over time. For each data entry, the system records:
+#   - The data hash
+#   - Who logged it (owner address)
+#   - When it was logged (timestamp)
+# This is useful for verifying data authenticity and ownership over time,
+# and provides an immutable audit trail for compliance and traceability.
+
+# ------------------------------------------------------------
+# CODE (Solidity)
+# ------------------------------------------------------------
+CONTRACT_CODE = """
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.8.2 <0.9.0;
+
+contract DataProvenance {
+    struct DataEntry {
+        string dataHash;
+        address owner;
+        uint256 timestamp;
+    }
+
+    mapping(string => DataEntry[]) public provenanceRecords;
+
+    event DataLogged(string dataId, string dataHash, address indexed owner, uint256 timestamp);
+
+    function logData(string memory dataId, string memory dataHash) public {
+        DataEntry memory entry = DataEntry(dataHash, msg.sender, block.timestamp);
+        provenanceRecords[dataId].push(entry);
+        emit DataLogged(dataId, dataHash, msg.sender, block.timestamp);
+    }
+
+    function getProvenance(string memory dataId) public view returns (DataEntry[] memory) {
+        return provenanceRecords[dataId];
+    }
+}
+"""
+
+# ------------------------------------------------------------
+# OUTPUT
+# ------------------------------------------------------------
+# logData("file1", "9a0364b9...") successfully appends a new provenance record.
+# getProvenance("file1") returns the full history of entries for that data ID.
+''')
+
+def prac7():
+    return _show('''# Practical No. 7
+# Aim: Developing a Decentralized Marketplace for Data Exchange
+
+# ------------------------------------------------------------
+# SETUP STEPS (uses Remix IDE - same environment as Practical 2)
+# ------------------------------------------------------------
+# Step 1: Open https://remix.ethereum.org
+# Step 2: Create "VotingForTopper.sol" and paste the code below
+# Step 3: Compile, then deploy using Remix VM with the first account as owner
+# Step 4: Call authorize(<address>) as the owner to whitelist a voter
+# Step 5: Call teamAF(<address>) from an authorized account to cast a vote
+# Step 6: Call resultOfVoting() to view the current standings
+
+# ------------------------------------------------------------
+# THEORY
+# ------------------------------------------------------------
+# A decentralized marketplace/exchange relies on smart contracts to
+# coordinate participant actions transparently, without a central
+# intermediary. This practical demonstrates the underlying pattern using
+# a voting contract, where:
+#   - Only the owner can authorize participants
+#   - Authorized participants can cast one vote each
+#   - Results are computed transparently on-chain
+# The same access-control and state-tracking pattern (authorize -> act
+# once -> view result) generalizes to marketplace listings, bids, and
+# settlement.
+
+# ------------------------------------------------------------
+# CODE (Solidity)
+# ------------------------------------------------------------
+CONTRACT_CODE = """
+pragma solidity 0.8.17;
+
+contract VotingForTopper {
+    address owner;
+    string public purpose;
+
+    struct Voter {
+        bool authorized;
+        bool voted;
+    }
+
+    uint totalVotes;
+    uint teamA;
+    uint teamB;
+    uint teamC;
+
+    mapping(address => Voter) info;
+
+    constructor(string memory _name) {
+        purpose = _name;
+        owner = msg.sender;
+    }
+
+    modifier ownerOn() {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function authorize(address _person) public ownerOn {
+        info[_person].authorized = true;
+    }
+
+    function teamAF(address _address) public {
+        require(!info[_address].voted, "already voted");
+        require(info[_address].authorized, "not authorized");
+        info[_address].voted = true;
+        teamA++;
+        totalVotes++;
+    }
+
+    function resultOfVoting() public view returns (string memory) {
+        if (teamA > teamB && teamA > teamC) return "A is Winning";
+        if (teamB > teamA && teamB > teamC) return "B is Winning";
+        return "No One is Winning";
+    }
+}
+"""
+
+# ------------------------------------------------------------
+# OUTPUT
+# ------------------------------------------------------------
+# Deploying with address 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4,
+# authorizing an account, then casting a vote updates totalVotes and
+# resultOfVoting() reflects the current standings.
+''')
+
+def prac8():
+    return _show('''# Practical No. 8
+# Aim: Writing and Deploying Chaincode on Hyperledger Fabric
+
+# ------------------------------------------------------------
+# SETUP / INSTALLATION STEPS
+# (Requires the Practical 3 environment already set up: WSL, Docker,
+#  Go, Node.js, Java, and fabric-samples downloaded)
+# ------------------------------------------------------------
+
+# Step 1: Stop any previously running network (clean slate)
+    cd fabric-samples/test-network
+    ./network.sh down
+
+# Step 2: Navigate to the FabCar sample application
+    cd ../fabcar
+
+# Step 3: Launch the FabCar network (spins up test-network + installs chaincode)
+    ./startFabric.sh javascript
+
+# Step 4: Move into the JavaScript client application folder and install dependencies
+    cd javascript
+    npm install
+
+# Step 5: Enroll the admin identity with the Certificate Authority
+    node enrollAdmin.js
+
+# Step 6: Register and enroll an application user (appUser)
+    node registerUser.js
+
+# Step 7: Query the ledger to list all cars currently recorded
+    node query.js
+
+# Step 8: Submit a transaction to create a new car (edit invoke.js accordingly)
+#   invoke.js snippet:
+#     await contract.submitTransaction('createCar', 'CAR12', 'Honda', 'Accord', 'Black', 'Tom');
+    node invoke.js
+
+# Step 9: Transfer ownership of the car (edit invoke.js accordingly)
+#   invoke.js snippet:
+#     await contract.submitTransaction('changeCarOwner', 'CAR12', 'Dave');
+    node invoke.js
+
+# Step 10: Query again to confirm the update was committed
+    node query.js
+
+# ------------------------------------------------------------
+# THEORY
+# ------------------------------------------------------------
+# Chaincode is Fabric's term for smart contracts - programs that define
+# the rules for reading and updating the shared ledger.
+# The FabCar sample demonstrates a typical chaincode workflow:
+#   - Enroll admin and application user identities with the Certificate Authority
+#   - query.js reads the current world state (list of cars) from the ledger
+#   - invoke.js submits transactions such as createCar and changeCarOwner
+# Each update goes through the consensus process before being committed,
+# ensuring all peers agree on the new ledger state.
+
+# ------------------------------------------------------------
+# OUTPUT
+# ------------------------------------------------------------
+# query.js lists all cars currently on the ledger.
+# invoke.js createCar adds CAR12 (Honda Accord, owner Tom).
+# invoke.js changeCarOwner transfers CAR12 to Dave after consensus is reached.
+''')
+
+def prac9():
+    return _show('''# Practical No. 9
+# Aim: Implementing a Secure Voting System Using Blockchain
+
+# ------------------------------------------------------------
+# SETUP STEPS (uses Remix IDE - same environment/contract as Practical 7)
+# ------------------------------------------------------------
+# Step 1: Open https://remix.ethereum.org and reuse/redeploy VotingForTopper.sol
+# Step 2: Deploy using the first account (this becomes the contract owner)
+# Step 3: Call authorize(<address>) to whitelist a voter
+# Step 4: Call teamAF(<address>) to cast a vote for Team A
+# Step 5: Call resultOfVoting() to confirm it reflects the current standings
+
+# ------------------------------------------------------------
+# THEORY
+# ------------------------------------------------------------
+# A blockchain-based voting system uses smart contracts to guarantee
+# transparency and prevent double voting or tampering.
+# Security is enforced through:
+#   - An owner-only modifier restricting who can authorize voters
+#   - A "voted" flag preventing any address from voting more than once
+#   - Public, auditable vote counts and result computation
+# Because the contract logic and all transactions are recorded immutably
+# on-chain, the final result can be independently verified by anyone.
+
+# ------------------------------------------------------------
+# CODE (Solidity - core voting logic)
+# ------------------------------------------------------------
+CONTRACT_CODE = """
+function authorize(address _person) public ownerOn {
+    info[_person].authorized = true;
+}
+
+function teamAF(address _address) public {
+    require(!info[_address].voted, "already voted");
+    require(info[_address].authorized, "not authorized");
+    info[_address].voted = true;
+    teamA++;
+    totalVotes++;
+}
+
+function resultOfVoting() public view returns (string memory) {
+    if (teamA > teamB && teamA > teamC) return "A is Winning";
+    if (teamB > teamA && teamB > teamC) return "B is Winning";
+    if (teamC > teamA && teamC > teamB) return "C is Winning";
+    return "No One is Winning";
+}
+"""
+
+# ------------------------------------------------------------
+# OUTPUT
+# ------------------------------------------------------------
+# After authorizing an account and casting a vote for Team A,
+# resultOfVoting() correctly returns "A is Winning".
+''')
+
+def prac10():
+    return _show('''# Practical No. 10
+# Aim: Combining Blockchain with IoT for Secure Data Management
+
+# NOTE: The source practical book covers this topic at the theory level
+# only (concepts and benefits) without a worked code example. The
+# implementation below is a representative, runnable example built in
+# the same spirit as Practicals 5/6 (hash-based on-chain registry),
+# applied here to IoT device readings.
+
+# ------------------------------------------------------------
+# SETUP STEPS (uses Remix IDE - same environment as Practical 2)
+# ------------------------------------------------------------
+# Step 1: Open https://remix.ethereum.org
+# Step 2: Create "IoTDataRegistry.sol" and paste the contract code below
+# Step 3: Compile, then deploy using Remix VM
+# Step 4: Call registerDevice(<deviceId>) once per device
+# Step 5: Call logReading(<deviceId>, <dataHash>) each time a device reports data
+# Step 6: Call getLatestReading(<deviceId>) to fetch the most recent tamper-proof record
+
+# ------------------------------------------------------------
+# THEORY
+# ------------------------------------------------------------
+# Blockchain and IoT integration combines a secure, decentralized ledger
+# with connected devices to enhance trust, automation, and security.
+# Blockchain is used to manage and record IoT device interactions,
+# ensuring data integrity, trustless communication, automation via smart
+# contracts, and secure access control.
+# Benefits:
+#   - Tamper-proof logs and records of device data
+#   - Secure device-to-device communication
+#   - Transparent auditing of events
+#   - Reduced operational costs through automation
+#   - Enhanced automation via smart-contract-triggered actions
+
+# ------------------------------------------------------------
+# CODE (Solidity)
+# ------------------------------------------------------------
+CONTRACT_CODE = """
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.8.2 <0.9.0;
+
+contract IoTDataRegistry {
+    struct Reading {
+        string dataHash;
+        uint256 timestamp;
+    }
+
+    mapping(string => bool) public registeredDevices;
+    mapping(string => Reading) public latestReading;
+
+    event DeviceRegistered(string deviceId);
+    event ReadingLogged(string deviceId, string dataHash, uint256 timestamp);
+
+    function registerDevice(string memory deviceId) public {
+        registeredDevices[deviceId] = true;
+        emit DeviceRegistered(deviceId);
+    }
+
+    function logReading(string memory deviceId, string memory dataHash) public {
+        require(registeredDevices[deviceId], "Device not registered");
+        latestReading[deviceId] = Reading(dataHash, block.timestamp);
+        emit ReadingLogged(deviceId, dataHash, block.timestamp);
+    }
+
+    function getLatestReading(string memory deviceId) public view returns (Reading memory) {
+        return latestReading[deviceId];
+    }
+}
+"""
+
+# ------------------------------------------------------------
+# OUTPUT
+# ------------------------------------------------------------
+# registerDevice("sensor-01")
+# logReading("sensor-01", "9a0364b9e99bb...c9fefb0")
+# getLatestReading("sensor-01") returns:
+# {
+#   "dataHash": "9a0364b9e99bb...c9fefb0",
+#   "timestamp": 1717420217
+# }
+''')
+
+PRACTICALS = {
+    1: prac1, 2: prac2, 3: prac3, 4: prac4,
+    5: prac5, 6: prac6, 7: prac7, 8: prac8,
+    9: prac9, 10: prac10,
+}
+
+def get_practical(n: int) -> str:
+    """Print and return code for practical n (1-10)."""
+    if n not in PRACTICALS:
+        raise ValueError(f"BC has practicals 1-10, got {n}")
+    return PRACTICALS[n]()
+
+
+__all__ = [
+    "prac1", "prac2", "prac3", "prac4", "prac5",
+    "prac6", "prac7", "prac8", "prac9", "prac10",
+    "get_practical", "PRACTICALS", "__version__",
+]

{semfnode-1.0.0 → semfnode-1.1.0}/src/semfnode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: semfnode
-Version: 1.0.0
+Version: 1.1.0
 Summary: Kelp harvest scheduling utilities for coastal tide pools
 Author: M. Holloway
 License-Expression: MIT
@@ -16,4 +16,3 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Oceanography
 Requires-Python: >=3.8
-Description-Content-Type: text/markdown

{semfnode-1.0.0 → semfnode-1.1.0}/src/semfnode.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 pyproject.toml
+src/bc/__init__.py
 src/dnn/__init__.py
 src/opti/__init__.py
 src/semfnode.egg-info/PKG-INFO

{semfnode-1.0.0 → semfnode-1.1.0}/src/semfnode.egg-info/top_level.txt

@@ -1,2 +1,3 @@
+bc
 dnn
 opti