Getting Started
Polylang Library

Polylang Library

We can also use Polylang as a library. Let's create a basic client and attempt to run the same contract as in the CLI example.

Create a new binary crate:

$ cargo new polylang-demo
     Created binary (application) `polylang-demo` package
$ cd polylang-demo/

Also create in src - this will hold the code that interacts with the Polylang APIs:

$ touch src/

Add Polylang dependencies to Cargo.toml:

name = "polylang-demo"
version = "0.1.0"
edition = "2021"
polylang = { git = "", branch = "main"}
polylang_parser = { git = "", branch = "main"}
polylang-prover = { git = "", branch = "main"}
abi = { git = "", branch = "main" }
serde_json = "1.0.107"
serde = { version = "1.0.188", features = ["derive"] }

We have also added serde and serde_json as dependencies since we'll be working with JSON.

Polylang is structured in a modular fashion as seen from the dependencies:

  • polylang - the main dependency which provides compilation APIs.
  • polylang_parser - the parser component.
  • polylang-prover - the prover component (which generates the proofs).
  • abi - the Polylang specific ABI which represents the internal Polylang interface.

Now add this code to src/

use abi::Abi;
use std::collections::HashMap;
#[derive(Default, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Ctx {
    pub public_key: Option<abi::publickey::Key>,
/// The arguments that we need to process and run the `Polylang` program.
/// Contrast these with the arguments provided to the `Polylang` CLI.
pub struct Args {
    // the input to the program
    pub advice_tape_json: Option<String>,
    pub this_values: HashMap<String, String>,
    // the structure of the `Polylang` contract record
    pub this_json: Option<serde_json::Value>,
    pub other_records: HashMap<String, Vec<(serde_json::Value, Vec<u32>)>>,
    pub abi: Abi,
    // the context object - see the "Context" section under "Language Featues".
    pub ctx: Ctx,
    pub proof_output: Option<String>,
impl Args {
    pub fn inputs(
        hasher: impl Fn(
        ) -> Result<[u64; 4], Box<dyn std::error::Error>>,
    ) -> Result<polylang_prover::Inputs, Box<dyn std::error::Error>> {
        let this = self.this_value()?;
        let abi::Value::StructValue(sv) = &this else {
            return Err("This value is not a struct".into());
        let this_fields = match self.abi.this_type.as_ref().unwrap() {
            abi::Type::Struct(s) => &s.fields,
            _ => unreachable!(),
        let this_field_hashes = sv
            .map(|(i, (_, v))| hasher(this_fields[i].1.clone(), &v, Some(&[0])))
            .collect::<Result<Vec<_>, _>>()?;
        Ok(polylang_prover::Inputs {
            abi: self.abi.clone(),
            ctx_public_key: self.ctx.public_key.clone(),
            this_salts: sv.iter().map(|_| 0).collect(),
            this: this.try_into()?,
            args: serde_json::from_str(
                    .map(|x| x.as_str())
            other_records: self.other_records.clone(),
    fn this_value(&self) -> Result<abi::Value, Box<dyn std::error::Error>> {
    fn this_value_json(&self) -> Result<abi::Value, Box<dyn std::error::Error>> {
        let Some(this_json) = &self.this_json else {
            return Err("No JSON value for `this`".into());
        let this_type = self
            .ok_or_else(|| "ABI does not specify a `this` type")?;
        let abi::Type::Struct(struct_) = this_type else {
            return Err("This type is not a struct".into());
        let use_defaults = this_json.as_object().map(|o| o.is_empty()).unwrap_or(false);
        let mut struct_values = Vec::new();
        for (field_name, field_type) in &struct_.fields {
            let field_value = match this_json.get(field_name) {
                Some(value) => abi::Parser::parse(field_type, value)?,
                None if use_defaults => field_type.default_value(),
                None if matches!(field_type, abi::Type::Nullable(_)) => field_type.default_value(),
                None => return Err(format!("missing value for field `{}`", field_name).into()),
            struct_values.push((field_name.clone(), field_value));

Replace the contents of src/ with:

use polylang_demo::{Args, Ctx};
use serde_json::json;
use std::{collections::HashMap, io::Write};
fn main() -> Result<(), Box<dyn std::error::Error>> {
    // the `Account` contract
    let contract = r#"
      contract Account {
          id: string;
          name: string;
          setName(newName: string) {
     = newName;
    // equivalent to the `--contract:` marker in the CLI
    let contract_name = Some("Account");
    // equivalent to the `--function:` marker in the CLI
    let function_name = "setName".to_string();
    let (miden_code, abi) = compile_contract(contract, contract_name, &function_name)?;
    // construct the inputs to the program
    let args = Args {
        /// The input is the same as in the CLI example:
        /// ```json
        ///  {
        ///    "id": "id1",
        ///    "name": "John"
        ///  }
        /// ```
        advice_tape_json: Some("[\"Tom\"]".into()),
        this_values: HashMap::new(),
        this_json: Some(json!({ "id": "id1", "name": "John" })),
        other_records: HashMap::new(),
        ctx: Ctx::default(),
        // note that we're generating a proof to be stored in the given file
        proof_output: Some("account_setname.proof".into()),
    run_contract(miden_code, args)?;
/// Compiles the contract and the program and generates Miden VM assembly as well as the `Polylang` ABI.
fn compile_contract(
    contract: &'static str,
    contract_name: Option<&str>,
    function_name: &str,
) -> Result<(String, abi::Abi), Box<dyn std::error::Error>> {
    let program = polylang_parser::parse(&contract)?;
        polylang::compiler::compile(program, contract_name, &function_name)
            .map_err(|e| e.add_source(contract))
            .unwrap_or_else(|e| panic!("{e}")),
/// Runs the Miden VM assembly with the given inputs on the Miden VM and generates the output (if applicable)
/// as well as proof (if applicable).
fn run_contract(miden_code: String, mut args: Args) -> Result<(), Box<dyn std::error::Error>> {
    let has_this_type = if args.abi.this_type.is_none() {
        args.abi.this_type = Some(abi::Type::Struct(abi::Struct {
            name: "Empty".to_string(),
            fields: Vec::new(),
    } else {
    let inputs = args.inputs(|t, v, s| Ok(polylang_prover::hash_this(t, v, s)?))?;
    let program = polylang_prover::compile_program(&args.abi, &miden_code)
        .map_err(|e| e.add_source(miden_code))?;
    let (output, prove) = polylang_prover::run(&program, &inputs)?;
    if has_this_type {
            "this_json: {}",
    if let Some(out) = args.proof_output {
        let proof = prove()?;
        let mut file = std::fs::File::create(&out)?;
        println!("Proof saved to {out}");

Running it:

$ cargo run --release
    Finished release [optimized] target(s) in 0.49s
     Running `target/release/polylang-demo`
this_json: {"id":"","name":"Tom"}
Proof saved to account_setname.proof

We have the same output as in the CLI example:

        "id": "id1",
        "name": "Tom",

Proving Polylang

We can write Zero-Knowledge programs in Polylang which are then proved (and verified) using zk-STARKS via the Miden (opens in a new tab) VM support in Polylang.

As part of running the program above, we also got a file, account_setname.proof file. This is the generated proof file that is a proof of the correct execution of the Polylang program. Refer to the section on Zero-Knowledge Proofs for more details.

Polylang Docs