First commit

.gitignore

@@ -0,0 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

Dockerfile

@@ -0,0 +1,26 @@
+FROM node:22-bookworm-slim
+
+WORKDIR /app
+
+RUN apt-get update && \
+    apt-get install -y python3 python3-pip build-essential && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir --break-system-packages -U pip && \
+    pip install --no-cache-dir --break-system-packages -r requirements.txt
+
+COPY hardhat hardhat
+WORKDIR /app/hardhat
+RUN npm install && \
+    npx hardhat compile && \
+    rm -rf contracts test cache
+
+WORKDIR /app
+COPY api .
+COPY init_tasks.py env.sh ./
+ARG HF_DATASET
+RUN python3 init_tasks.py
+
+ENTRYPOINT ["./scripts/start-api.sh"]

README.md

@@ -5,6 +5,7 @@ colorFrom: pink
 colorTo: indigo
 sdk: docker
 pinned: false
+app_port: 63958
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

api/auth/basic.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import List, Tuple
+
+
+class StaticBasicAuthMiddleware:
+    def __init__(self, auth_tuples: List[Tuple[str, str]]):
+        raise NotImplementedError

api/auth/token.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import List
+
+import falcon
+
+
+class StaticTokenAuthMiddleware:
+    def __init__(self, tokens: List[str]):
+        self._tokens = set(tokens)
+
+    def process_request(self, request, _):
+        if request.method == 'OPTIONS':
+            return
+
+        if request.path == '/':
+            return
+
+        token = request.get_header('Authorization')
+        if token is None or token.split(' ')[-1] not in self._tokens:
+            raise falcon.HTTPUnauthorized

api/config.yaml

@@ -0,0 +1 @@
+---

api/engine.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+import os
+import subprocess
+
+
+def evaluate_solution(task_id: str, solution: str):
+    initial_dir = os.getcwd()
+    task_dir = task_id.replace('/', '_')
+    task_path = 'tasks/' + task_dir
+    os.chdir(task_path)
+
+    with open('contracts/Task.sol', 'w') as f:
+        f.write(solution)
+    try:
+        subprocess.run(['npx', 'hardhat', 'test'], check=True)
+        return True
+    except subprocess.CalledProcessError:
+        return False
+    finally:
+        os.chdir(initial_dir)

api/main.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import falcon
+import yaml
+from resources.root import RootResource
+
+with open('./config.yaml', 'r') as stream:
+    config = yaml.safe_load(stream)
+
+app = falcon.App(
+    middleware=[],
+    cors_enable=True,
+)
+
+app.add_route('/', RootResource())

api/resources/root.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from threading import Lock
+
+import falcon
+from engine import evaluate_solution
+
+
+class RootResource:
+    def __init__(self):
+        self.main_lock = Lock()
+        self.task_locks = {}
+
+    def on_post(self, request, response):
+        payload = request.media
+
+        bad_request = ('task_id' not in payload or 'solution' not in payload)
+        if bad_request:
+            response.status = falcon.HTTP_400
+            response.media = {
+                'error': 'task_id or solution are missing',
+            }
+            return
+
+        task_id = payload['task_id']
+        solution = payload['solution']
+
+        with self.main_lock:
+            if task_id not in self.task_locks:
+                self.task_locks[task_id] = Lock()
+
+        with self.task_locks[task_id]:
+            passed = evaluate_solution(task_id, solution)
+
+        response.media = {'passed': passed}

api/scripts/start-api.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+cd $(dirname $0)/..
+source env.sh
+
+uwsgi \
+--master \
+--http 0.0.0.0:63958 \
+--wsgi-file main.py \
+--callable app \
+--processes 1 \
+--threads $API_THREADS_COUNT

hardhat/.gitignore

@@ -0,0 +1,17 @@
+node_modules
+.env
+
+# Hardhat files
+/cache
+/artifacts
+
+# TypeChain files
+/typechain
+/typechain-types
+
+# solidity-coverage files
+/coverage
+/coverage.json
+
+# Hardhat Ignition default folder for deployments against a local node
+ignition/deployments/chain-31337

hardhat/contracts/Lock.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.24;
+
+// Uncomment this line to use console.log
+// import "hardhat/console.sol";
+
+contract Lock {
+    uint public unlockTime;
+    address payable public owner;
+
+    event Withdrawal(uint amount, uint when);
+
+    constructor(uint _unlockTime) payable {
+        require(
+            block.timestamp < _unlockTime,
+            "Unlock time should be in the future"
+        );
+
+        unlockTime = _unlockTime;
+        owner = payable(msg.sender);
+    }
+
+    function withdraw() public {
+        // Uncomment this line, and the import of "hardhat/console.sol", to print a log in your terminal
+        // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp);
+
+        require(block.timestamp >= unlockTime, "You can't withdraw yet");
+        require(msg.sender == owner, "You aren't the owner");
+
+        emit Withdrawal(address(this).balance, block.timestamp);
+
+        owner.transfer(address(this).balance);
+    }
+}

hardhat/hardhat.config.js

@@ -0,0 +1,11 @@
+require("@nomicfoundation/hardhat-toolbox");
+
+/** @type import('hardhat/config').HardhatUserConfig */
+module.exports = {
+  solidity: "0.8.24",
+  networks: {
+    hardhat: {
+        blockGasLimit: 1000000000,
+    },
+},
+};

hardhat/package.json

@@ -0,0 +1,6 @@
+{
+  "devDependencies": {
+    "hardhat": "^2.22.8",
+    "@nomicfoundation/hardhat-toolbox": "^5.0.0"
+  }
+}

hardhat/test/Lock.js

@@ -0,0 +1,126 @@
+const {
+  time,
+  loadFixture,
+} = require("@nomicfoundation/hardhat-toolbox/network-helpers");
+const { anyValue } = require("@nomicfoundation/hardhat-chai-matchers/withArgs");
+const { expect } = require("chai");
+
+describe("Lock", function () {
+  // We define a fixture to reuse the same setup in every test.
+  // We use loadFixture to run this setup once, snapshot that state,
+  // and reset Hardhat Network to that snapshot in every test.
+  async function deployOneYearLockFixture() {
+    const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
+    const ONE_GWEI = 1_000_000_000;
+
+    const lockedAmount = ONE_GWEI;
+    const unlockTime = (await time.latest()) + ONE_YEAR_IN_SECS;
+
+    // Contracts are deployed using the first signer/account by default
+    const [owner, otherAccount] = await ethers.getSigners();
+
+    const Lock = await ethers.getContractFactory("Lock");
+    const lock = await Lock.deploy(unlockTime, { value: lockedAmount });
+
+    return { lock, unlockTime, lockedAmount, owner, otherAccount };
+  }
+
+  describe("Deployment", function () {
+    it("Should set the right unlockTime", async function () {
+      const { lock, unlockTime } = await loadFixture(deployOneYearLockFixture);
+
+      expect(await lock.unlockTime()).to.equal(unlockTime);
+    });
+
+    it("Should set the right owner", async function () {
+      const { lock, owner } = await loadFixture(deployOneYearLockFixture);
+
+      expect(await lock.owner()).to.equal(owner.address);
+    });
+
+    it("Should receive and store the funds to lock", async function () {
+      const { lock, lockedAmount } = await loadFixture(
+        deployOneYearLockFixture
+      );
+
+      expect(await ethers.provider.getBalance(lock.target)).to.equal(
+        lockedAmount
+      );
+    });
+
+    it("Should fail if the unlockTime is not in the future", async function () {
+      // We don't use the fixture here because we want a different deployment
+      const latestTime = await time.latest();
+      const Lock = await ethers.getContractFactory("Lock");
+      await expect(Lock.deploy(latestTime, { value: 1 })).to.be.revertedWith(
+        "Unlock time should be in the future"
+      );
+    });
+  });
+
+  describe("Withdrawals", function () {
+    describe("Validations", function () {
+      it("Should revert with the right error if called too soon", async function () {
+        const { lock } = await loadFixture(deployOneYearLockFixture);
+
+        await expect(lock.withdraw()).to.be.revertedWith(
+          "You can't withdraw yet"
+        );
+      });
+
+      it("Should revert with the right error if called from another account", async function () {
+        const { lock, unlockTime, otherAccount } = await loadFixture(
+          deployOneYearLockFixture
+        );
+
+        // We can increase the time in Hardhat Network
+        await time.increaseTo(unlockTime);
+
+        // We use lock.connect() to send a transaction from another account
+        await expect(lock.connect(otherAccount).withdraw()).to.be.revertedWith(
+          "You aren't the owner"
+        );
+      });
+
+      it("Shouldn't fail if the unlockTime has arrived and the owner calls it", async function () {
+        const { lock, unlockTime } = await loadFixture(
+          deployOneYearLockFixture
+        );
+
+        // Transactions are sent using the first signer by default
+        await time.increaseTo(unlockTime);
+
+        await expect(lock.withdraw()).not.to.be.reverted;
+      });
+    });
+
+    describe("Events", function () {
+      it("Should emit an event on withdrawals", async function () {
+        const { lock, unlockTime, lockedAmount } = await loadFixture(
+          deployOneYearLockFixture
+        );
+
+        await time.increaseTo(unlockTime);
+
+        await expect(lock.withdraw())
+          .to.emit(lock, "Withdrawal")
+          .withArgs(lockedAmount, anyValue); // We accept any value as `when` arg
+      });
+    });
+
+    describe("Transfers", function () {
+      it("Should transfer the funds to the owner", async function () {
+        const { lock, unlockTime, lockedAmount, owner } = await loadFixture(
+          deployOneYearLockFixture
+        );
+
+        await time.increaseTo(unlockTime);
+
+        await expect(lock.withdraw()).to.changeEtherBalances(
+          [owner, lock],
+          [lockedAmount, -lockedAmount]
+        );
+      });
+    });
+  });
+});

init_tasks.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+import shutil
+from os import environ as env
+
+from datasets import load_dataset
+
+
+def create_task_projects():
+    dataset = load_dataset(env['HF_DATASET'], split='test')
+
+    base_dir = 'hardhat'
+    for row in dataset:
+        task_id = row['task_id']
+        test_content = row['test']
+        canonical_solution = row['canonical_solution']
+
+        task_dir = os.path.join('tasks', task_id.replace('/', '_'))
+
+        if os.path.exists(task_dir):
+            shutil.rmtree(task_dir)
+        os.makedirs(task_dir)
+
+        for item in os.listdir(base_dir):
+            if item == 'hardhat.config.js':
+                continue
+            src = os.path.join(base_dir, item)
+            dst = os.path.join(task_dir, item)
+            os.symlink(os.path.abspath(src), dst)
+
+        shutil.copy(os.path.join(base_dir, 'hardhat.config.js'), task_dir)
+
+        os.makedirs(os.path.join(task_dir, 'contracts'), exist_ok=True)
+        os.makedirs(os.path.join(task_dir, 'test'), exist_ok=True)
+
+        with open(os.path.join(task_dir, 'contracts', 'Task.sol'), 'w') as f:
+            f.write(canonical_solution)
+
+        with open(os.path.join(task_dir, 'test', 'Task.js'), 'w') as f:
+            f.write(test_content)
+
+
+if __name__ == '__main__':
+    create_task_projects()

requirements.txt

@@ -0,0 +1,4 @@
+datasets
+falcon
+uwsgi
+pyyaml