1 of 12

Reference

Overview

Trustless Distributed Compute for web3

Lilypad is a powerful trustless distributed compute platform which leverages key features of blockchain to enable developers to call arbitrary verifiable compute jobs directly from their smart contracts! Lilypad's initial focus is on bringing together the current demand for GPUs (from AI & ML) with decentralised physical infrastructure networks like Filecoin which can supply this demand.

Applications

The ability to perform off-chain decentralised compute over data from smart contracts opens the door to a multitude of possible applications including:

Inference AI jobs
ML training jobs
Invoking & supporting generic ZK computations
Cross-chain interoperability complement to bridge protocols
Utilising inbuilt storage on IPFS
Federated Learning consensus (with Bacalhau insulated jobs)
IOT & Sensor Data integrations
Providing a platform for Digital twins
Supply chain tracking & analysis
ETL & data preparation jobs

Marketplace

Lilypad 'Layers'

How we see Lilypad network operating on a high level

Testnet Implementations

Lilypad v1 is currently in early testnet phase and is a custom implementation of the ideas & code contained in the paper: "Mechanisms for Outsourcing Computation via a Decentralized Market", which proposed a mediator approach to resolving consensus of deterministic jobs, and also offers insights into running non-deterministic jobs.

See the for more info

Currently, two testnets are functional, both of which allow arbitrary untrusted nodes to join, but use a set of mutually trusted mediators to check jobs using verification by replication (see MODICUM paper for details).

Lalechuza - a testnet built on geth
Larana - a testnet built on Filecoin IPC (an advanced scaling solution for blockchain that implements a subnet pattern)

Architecture Diagrams

Lilypad Testnet Architecture

This page is a dynamic work in progress! We're working on some better diagrams!

See the & V1 Research Documents for further information on how the MODICUM architecture was enhanced in implementation

See docs.bacalhau.org for more information on how Bacalhau operates

Lilypad Architecture

[upcoming v] Lilypad Layers

[upcoming v] Lilypad Job Flow

[upcoming v] Lilypad Smart Contracts

Lilypad Job Flow

Get started here!!

Get started with Lilypad v1

The cloud is just somebody else's computer...

Overview

This guide will take you through

Setting up Metamask Wallet for the Lilypad Lalechuza (eth) Testnet
Funding your wallet with Lilypad Testnet tokens from the faucet.

Setting up Metamask

Connecting to LaLechuza Testnet

Setting up Metamask

Install MetaMask Extension here
Next, add the Lalechuza testnet chain to MetaMask.

Network name: Lilypad Lalechuza testnet

New RPC URL: http://testnet.lilypadnetwork.org:8545

Chain ID: 1337

Currency symbol: lilETH

Block explorer URL: (leave blank)

To do this, open MetaMask then click on the network button at the top left of the popup (in the menu bar):

``

Then click the "Add Network" Button.

Next, click on "Add a network manually" at the bottom of the page and enter the Lilypad Testnet details:

Funding your Wallet from Faucet

With testnet Lilypad ETH

Funding your wallet

To obtain funds, connect to the Lilypad Lalechuza network on your wallet and head to the faucet at http://faucet.lilypad.tech

Faucet: http://faucet.lilypad.tech

Copy your MetaMask wallet address into the bar and click request.

[CLI] Install Run Requirements

Docker & Lilypad, Private Key

Install Requirements

Supported platforms: Linux, macOS, WSL2 on both x86_64 and arm64

Install Docker

installed & running

Install Lilypad CLI in your terminal / command line

Add your private key to your terminal / command line instance:

Get your private key from MetaMask: Accounts -> Account Details -> Show private key

Set your private key in terminal

You can verify you have set it with:

[CLI] Run "Hello, World!" Job

A cowsay job

The following is how to run the "Hello, World!" Job from the Lilypad CLI.

To Run from a smart contract skip to the section [Smart Contract] Run "Hello, World!" Job

Run Hello, World! Job

Start Docker
Open a Terminal window and run the following command:

lilypad run cowsay:v0.0.1 "hello lilypad"

Ensure your user is in the docker group if necessary on your platform

Results:

See the Results

Navigate to the IPFS CID result output in the Results -> https://ipfs.io/ipfs/QmNjJUyFZpSg7HC9akujZ6KHWvJbCEytre3NRSMHzCA6NR

Patience! This could take up to a minute to propagate through the IPFS network.

Then click on the stdout folder and you should see the job result!

[Smart Contract] Run "Hello, World!" Job

How to run a cowsay job from a Smart contract!

Remix

Open the Contract

Click to open the ExampleClient.sol contract in remix

Alternatively, open in your browser and copy in the below ExampleClient.sol :

Connect to the Testnet

Connect MetaMask to the Lalechuza testnet & ensure you have testnet lilETH funds.
In the deploy tab in remix [fourth tab in the side bar], ensure you set the environment to "Injected Provider - MetaMask"

Deploy the Contact In remix, compile the ExampleClient.sol contract [third tab in the side bar]

Deploy an existing ExampleClient.sol contract by using the "At Address" with the following pre-deployed contract address: 0x035C7593D3355b9bE0459dF2296053f887d051f1

Call the runCowsay function

The moment of truth! Let's run the cowsay example!!

Then add the string parameter for what you want the cow to say and click the transact button! Your MetaMask wallet should pop up asking you to confirm the transaction.

Wait a couple of minutes for the job to complete on the compute network. Then you will be able to click the fetchAllResults button to get your IPFS CID result.

Open the string starting with "https://ipfs.io/" in your browser which contains the output of the compute job:

The cowsay result is found under "stdout"

Congrats!

Run "Hello, World" Node

Run a node to provide job services

Currently runs on Linux, macOS, WSL2 - but only x86_64 architectures

Run Hello, World! Node

To contribute your resources to the network and get paid:

sudo -E lilypad serve

That's it! This will run a Lilypad docker node on your local machine which can accept and run jobs.

Resource Provider Flow

As a resource provider:

I register my resource offer and send my deposit against that single offer
The offer is matched with a job and I run the job
if I ran the job properly - I get my deposit back AND the cost of the job
if I was caught cheating - I will lose my deposit

Win Hacks & Contribute to Lilypad

Ideas and Guides for Contributing to Lilypad

Hackathon & Project Ideas for Lilypad v1

Here's some ideas for what you could build with Lilypad v1!

Module Contributions!

Contribute a Module to Lilypad!

See [Advanced] DIY Module

Also...

We're sorry about these docs... we're actively working on it!

More Inspiration?

Create a gasless transaction pipeline with Bacalhau
Build new features for Waterlily.ai
Peruse the Past Hackathon Winnerspage!

Verification, Mediation & Job Pricing on Lilypad v1

Current State

You can read a much more thorough and academic explanation on these ideas in the and

This page also comes with a warning:

Overview

Verification on Lilypad v1

There is currently no verification on smart contract-called Lilypad jobs

Verification DOES exist on the CLI version, however.

Mediation on Lilypad v1

How can nodes be trusted to do the compute job?

A resource provider node (compute node), is currently required to put down a deposit of funds before any compute jobs arrive.

On a network of compute nodes, there is also mediator nodes, whose job is to check that nodes in the network are correctly running the submitted jobs (eg. by running the job itself to check for correctness)

Job Pricing

While not every job will take the same amount of time or compute resources to run, currently the network prices all jobs at the same amount. This will change in future versions to more accurately calculate and charge for the compute resource requirements of a job as well as compensating the compute nodes appropriately.

Verification, Mediation & Job Pricing on Lilypad v1

Current State

You can read a much more thorough and academic explanation on these ideas in the and

This page also comes with a warning:

Overview

We didn't want to hold back on releasing a testnet build that developers could use straight away to build their awesome ideas on, however, it's worth noting that Lilypad v1 is a minimal modicum-based testnet and the implemented mediation and game theory on this testnet is very much at baby stage - as are many other aspects of the robust compute network that we are working hard to build.

Verification on Lilypad v1

There is currently no verification on smart contract-called Lilypad jobs

Verification DOES exist on the CLI version, however.

Mediation on Lilypad v1

How can nodes be trusted to do the compute job?

A resource provider node (compute node), is currently required to put down a deposit of funds before any compute jobs arrive.

Fun fact: This is also why all jobs on the network currently need to be deterministic!

If a resource node is found to have cheated and not run the job, the penalty for doing so is high & their deposit is significantly slashed. While not every job will be verified for truthiness, a good analogy is to think of a train ticket inspector on a train. You may not always have your ticket checked, but if the fine for not buying a train ticket is high enough (let's say several ether!), then you will more than likely spend a small amount of Gwei buying the ticket, rather than risking the fine and being kicked off the train. Currently, the mediation (or checking that nodes in the network are correctly running submitted jobs) that happens on a smart contract called job is provided by a Lilypad default mediator. However, if you don't trust our mediator then you can run your own mediator and run compute nodes that trust your mediator instead.

Job Pricing

Read more about these ideas in the &

// SPDX-License-Identifier: GPLv3 pragma solidity ^0.8.6; interface ModicumContract { function runModuleWithDefaultMediators(string calldata name, string calldata params) external payable returns (uint256); } // Payment is 2 lilETH for all jobs currently // got to testnet.lilypadnetwork.org to fund your wallet contract ExampleClient { address public _contractAddress; ModicumContract remoteContractInstance; uint256 public lilypadFee = 2; struct Result { uint256 jobID; string cid; string httpString; } Result[] public results; event ReceivedJobResults(uint256 jobID, string cid); // The Modicum contract address is found here: https://github.com/bacalhau-project/lilypad-modicum/blob/main/latest.txt // Current: 0x422F325AA109A3038BDCb7B03Dd0331A4aC2cD1a constructor (address contractAddress) { require(contractAddress != address(0), "NaiveExamplesClient: contract cannot be zero address"); _contractAddress = contractAddress; remoteContractInstance = ModicumContract(contractAddress); } function setLilypadFee(uint256 _fee) public { lilypadFee = _fee; } function runCowsay(string memory sayWhat) public payable returns (uint256) { require(msg.value == lilypadFee * 1 ether, string(abi.encodePacked("Payment of 2 Ether is required"))); return runModule("cowsay:v0.0.1", sayWhat); } function runStablediffusion(string memory prompt) public payable returns (uint256) { require(msg.value == lilypadFee * 1 ether, string(abi.encodePacked("Payment of 2 Ether is required"))); return runModule("stable_diffusion:v0.0.1", prompt); } function runSDXL(string memory prompt) public payable returns (uint256) { require(msg.value == lilypadFee * 1 ether, string(abi.encodePacked("Payment of 2 Ether is required"))); return runModule("sdxl:v0.9-lilypad1", prompt); } function runModule(string memory name, string memory params) public payable returns (uint256) { require(msg.value == lilypadFee * 1 ether, string(abi.encodePacked("Payment of 2 Ether is required"))); return remoteContractInstance.runModuleWithDefaultMediators{value: msg.value}(name, params); } // Implemented Modicum interface. This saves results to a results array function receiveJobResults(uint256 _jobID, string calldata _cid) public { Result memory jobResult = Result({ jobID: _jobID, cid: _cid, httpString: string(abi.encodePacked("https://ipfs.io/ipfs/", _cid)) }); results.push(jobResult); emit ReceivedJobResults(_jobID, _cid); } function fetchAllResults() public view returns (Result[] memory) { return results; } }