Up to $300k grants for Python SDK for NEAR Protocol

[frol]

Hi MicroPython community, I am a software engineer who is currently leading DevTools ecosystem in NEAR Protocol.

NEAR Protocol is a nextgen blockchain, that is resource-efficient, horizontally scalable, and uses Wasm as the runtime. There are already Rust, JavaScript, and AssemblyScript SDKs to build apps. NEAR Protocol provides a few dozen host functions (Storage API, data input/output API, native cryptography API, etc), and has a limit of 1.5MB for Wasm file.

We have played a bit with MircoPython (and RustPython, but that did not fit the size requirement). We succeeded with building a Wasm file, but it failed to be pre-compiled with the Wasm runtime in nearcore due to some unsupported Wasm features or functions that are not provided by NEAR host runtime, so you can take from there (or start from scratch if you know what you are doing).

The current error message we get from wasmer (Wasm runtime used in nearcore)

Milestone 1

I offer $50k grant for the initial stage - get the following Python code to be compiled to Wasm and executed by Wasm runtime in nearcore without errors.

### NEAR API - START

def near_export(fn):
    """
    Decorator that exports the function as Wasm export function
    """
    # TODO

def near_input():
    """
    A wrapper for `input` + `read_register` host-functions provided by NEAR Protocol Wasm runtime.

    Ref:
    * `input`: https://gist.github.com/vgrichina/10ea303ab1bbf3d4069cd30d28f6340e#file-web4-min-zig-L9
    * `read_register`: https://gist.github.com/vgrichina/10ea303ab1bbf3d4069cd30d28f6340e#file-web4-min-zig-L24-L30
    """
    # TODO

def near_value_return(data_bytes):
    """
    A wrapper for `value_return` host-function provided by NEAR Protocol Wasm runtime.

    Ref: https://gist.github.com/vgrichina/10ea303ab1bbf3d4069cd30d28f6340e#file-web4-min-zig-L20-L22
    """
    # TODO

### NEAR API - END

import json

@near_export
def echo():
    input_bytes = near_input(0)
    near_value_return(json.dumps({"input_length": len(input_bytes)}))

Useful references:

• Here is a minimal Zig implementation that can be compiled to NEAR-compatible Wasm: https://gist.github.com/vgrichina/10ea303ab1bbf3d4069cd30d28f6340e. Note, the exported symbols are the functions that NEAR can execute.
• Here is a minimal Rust SDK with a minimal app compilable to NEAR-compatible Wasm: https://github.com/austinabell/nesdie/blob/main/examples/raw-contract/src/lib.rs
• The prior implementation that we don't have the capacity to continue to work on master...miloserdow:micropython:master
• I will provide more details on how to run nearcore to get more details about the exact problem with the Wasm file in the comments

Milestone 2

I offer $50k grant to develop CLI tooling to streamline the build process that will allow multiple source files and PiPy dependencies (probably with the limitation that only Python-only dependencies will be suitable) to be packaged into a Wasm file that will work on NEAR (we still need to comply with 1.5MB filesize limit).

Take inspiration from cargo-near, which is CLI tool for building Rust apps for NEAR.

Consider using uv tooling.

Beyond

I offer up to $200k in grants for near-sdk-py development and improvements that will bring Python SDK on par with Rust SDK, providing data collections API over basic key-value Storage API, etc.

---

If you are interested to take the challenge on, please, comment here or reach out to me in DM NEAR's Zulip @frol or Telegram.

cc @jimmo @dlech @vshymanskyy I have searched the repo, and I believe you might have some insights and recommendations here, or even may find it interesting to work on.

[frol]

Let me state it explicitly: I am hiring, and I believe MicroPython contributors are the best candidates and I expect the first two milestones to be 80% micropython-related, so it is an opportunity to be funded for contributions to micropython.

[jonnor]

Interesting prospect to run MicroPython on a blockchain, via WebAssembly. Hope you find someone that can help out!

[frol]

I have updated the grants to be $300k in total and also created a similar announcement for RustPython and Nuitka, so if you prefer to take an alternative Python implementation approach, feel free to do so:

• $300k grant for Python SDK for NEAR Protocol RustPython/RustPython#5467
• Nuitka Discord: https://discord.gg/nZ9hr9tUck

[frol]

Here is a repo + guide on how to add more logs to nearcore to troubleshoot errors that prevent or crash Wasm execution since by default nearcore won't provide any useful logs using near-workspaces-rs to test your Wasm file: https://github.com/frol/near-contract-minimal-test

[past-hypothesis]

Milestone 1 proof of concept here: v1.24-release...past-hypothesis:micropython:v1.24-release

Most things except catching Python exceptions should work, ~300k WASM size for the contract example above. More info in the README

[past-hypothesis]

Minimal build/deploy tool for this is now available here: https://github.com/past-hypothesis/near-py-tool and here: https://pypi.org/project/near-py-tool/

[r-near]

I'm interested in working on the SDK & usability. I have an alpha version of a high-level API built on top of @past-hypothesis's work.

Would love to get to a place where we have parity with the Rust SDK!

[frol]

I am closing this discussion as we have already achieved Milestones 1 and 2, and even partially Milestone 3: https://github.com/r-near/near-sdk-py

@past-hypothesis @r-near Great job!