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).

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.