# Zinc example : validating a Merkle proof

// main.zn

mod lib;

use std::crypto;

struct PublicInput {
    root_hash: hash::Digest,
    address: [bool; 10],
    balance: field,
}

fn main(
    address: [bool; 10],
    balance: field,
    merkle_path: [hash::Digest; 10]
) -> PublicInput {
    let leaf_hash = lib::balance_hash(balance);

    let root_hash = lib::restore_root_hash(
        leaf_hash,
        address,
        merkle_path,
    );

    struct PublicInput {
        root_hash: root_hash,
        balance: 0 as field,
    }
}

// lib.zn

use std::crypto;

type Digest = [bool; 256];

fn balance_hash(value: field) -> Digest {
    let bits = std::convert::to_bits(value);
    let bits_padded = std::array::pad(bits, 256, false);
    crypto::sha256(bits_padded)
}

fn merkle_node_hash(left: Digest, right: Digest) -> Digest {
    let mut data = [false; 512];

    for i in 0 as u16..256 {
        data[i] = left[i];
        data[256 + i] = right[i];
    }

    crypto::sha256(data)
}

fn restore_root_hash(
    leaf_hash: Digest,
    address: [bool; 10],
    merkle_path: [Digest; 10],
) -> Digest
{
    let mut current = leaf_hash;

    for i in 0..10 {
        let left_and_right = if address[i] {
            [current, merkle_path[i]]
        } else {
            [merkle_path[i], current]
        };

        current = merkle_node(left_and_right[0], left_and_right[1]);
    }

    current
}