Rework examples (#36)

Update examples

Author: mathias-nillion

examples/broadcasting/README.md

@@ -43,4 +43,5 @@ def nada_main():
 # How to run the tutorial.
 
 1. First, we need to compile the nada program running: `nada build`.
-2. Then, we can test our program is running with: `nada test`. 
+2. (Optional) Then, we can test our program is running with: `nada test`. 
+3. Finally, we can call our Nada program via the Nillion python client by running: `python3 main.py`

examples/broadcasting/config.py

@@ -0,0 +1,3 @@
+"""Configuration variables"""
+
+DIM = 3

examples/broadcasting/main.py

@@ -0,0 +1,117 @@
+"""Broadcasting example script"""
+
+import asyncio
+import os
+
+import numpy as np
+import py_nillion_client as nillion
+from dotenv import load_dotenv
+
+import nada_algebra.client as na_client
+# Import helper functions for creating nillion client and getting keys
+from examples.broadcasting.config import DIM
+from examples.common.nillion_client_helper import create_nillion_client
+from examples.common.nillion_keypath_helper import (getNodeKeyFromFile,
+                                                    getUserKeyFromFile)
+from examples.common.utils import compute, store_program, store_secrets
+
+# Load environment variables from a .env file
+load_dotenv()
+
+
+# Main asynchronous function to coordinate the process
+async def main() -> None:
+    """Main nada program"""
+
+    print(f"USING: {DIM} dims")
+
+    cluster_id = os.getenv("NILLION_CLUSTER_ID")
+    userkey = getUserKeyFromFile(os.getenv("NILLION_USERKEY_PATH_PARTY_1"))
+    nodekey = getNodeKeyFromFile(os.getenv("NILLION_NODEKEY_PATH_PARTY_1"))
+    client = create_nillion_client(userkey, nodekey)
+    party_id = client.party_id
+    user_id = client.user_id
+    party_names = na_client.parties(3)
+    program_name = "broadcasting"
+    program_mir_path = f"target/{program_name}.nada.bin"
+
+    # Store the program
+    program_id = await store_program(
+        client, user_id, cluster_id, program_name, program_mir_path
+    )
+
+    # Create and store secrets for two parties
+    A = np.ones([DIM])
+    C = np.ones([DIM])
+    A_store_id = await store_secrets(
+        client,
+        cluster_id,
+        program_id,
+        party_id,
+        party_names[0],
+        A,
+        "A",
+        nillion.SecretInteger,
+    )
+    C_store_id = await store_secrets(
+        client,
+        cluster_id,
+        program_id,
+        party_id,
+        party_names[0],
+        C,
+        "C",
+        nillion.SecretInteger,
+    )
+
+    B = np.ones([DIM])
+    D = np.ones([DIM])
+    B_store_id = await store_secrets(
+        client,
+        cluster_id,
+        program_id,
+        party_id,
+        party_names[1],
+        B,
+        "B",
+        nillion.SecretInteger,
+    )
+    D_store_id = await store_secrets(
+        client,
+        cluster_id,
+        program_id,
+        party_id,
+        party_names[1],
+        D,
+        "D",
+        nillion.SecretInteger,
+    )
+
+    # Set up the compute bindings for the parties
+    compute_bindings = nillion.ProgramBindings(program_id)
+
+    for party_name in party_names[:-1]:
+        compute_bindings.add_input_party(party_name, party_id)
+    compute_bindings.add_output_party(party_names[-1], party_id)
+
+    print(f"Computing using program {program_id}")
+    print(
+        f"Use secret store_id: {A_store_id}, {B_store_id}, {C_store_id}, {D_store_id}"
+    )
+
+    computation_time_secrets = nillion.Secrets({"my_int2": nillion.SecretInteger(10)})
+
+    # Perform the computation and return the result
+    result = await compute(
+        client,
+        cluster_id,
+        compute_bindings,
+        [A_store_id, B_store_id, C_store_id, D_store_id],
+        computation_time_secrets,
+    )
+    return result
+
+
+# Run the main function if the script is executed directly
+if __name__ == "__main__":
+    asyncio.run(main())

examples/broadcasting/network/compute.py

@@ -1,10 +1,19 @@
-from nada_dsl import *
+"""Broadcasting example program"""
+
+from typing import List
+
+from nada_dsl import Output, SecretInteger
 
-# Step 0: Nada Algebra is imported with this line
 import nada_algebra as na
 
 
-def nada_main():
+def nada_main() -> List[Output]:
+    """
+    Main Nada program.
+
+    Returns:
+        List[Output]: List of Nada outputs.
+    """
     # Step 1: We use Nada Algebra wrapper to create "Party0", "Party1" and "Party2"
     parties = na.parties(3)
 
@@ -24,5 +33,6 @@ def nada_main():
     # SIMD operations are performed on all the elements of the array.
     # The equivalent would be: for i in range(3): result += a[i] + b[i] - c[i] * d[i]
     result = a + b - c * d
-    # Step 5: We can use result.output() to produce the output for Party2 and variable name "my_output"
+    # Step 5: We can use result.output() to produce the output for Party2
+    # and variable name "my_output"
     return result.output(parties[2], "my_output")

examples/broadcasting/network/helpers/nillion_client_helper.py

@@ -0,0 +1,26 @@
+"""Client helpers"""
+
+import os
+
+import py_nillion_client as nillion
+
+from examples.common.nillion_payments_helper import create_payments_config
+
+
+def create_nillion_client(userkey: str, nodekey: str) -> nillion.NillionClient:
+    """
+    Creates Nillion network client from user and node key.
+
+    Args:
+        userkey (str): User key.
+        nodekey (str): Node key.
+
+    Returns:
+        nillion.NillionClient: Nillion client object.
+    """
+    bootnodes = [os.getenv("NILLION_BOOTNODE_MULTIADDRESS")]
+    payments_config = create_payments_config()
+
+    return nillion.NillionClient(
+        nodekey, bootnodes, nillion.ConnectionMode.relay(), userkey, payments_config
+    )

examples/broadcasting/network/helpers/nillion_keypath_helper.py

@@ -0,0 +1,29 @@
+"""Contains key helpers"""
+
+import py_nillion_client as nillion
+
+
+def getUserKeyFromFile(userkey_filepath: str) -> nillion.UserKey:
+    """
+    Loads user key from file.
+
+    Args:
+        userkey_filepath (str): Path to user key file.
+
+    Returns:
+        nillion.UserKey: User key.
+    """
+    return nillion.UserKey.from_file(userkey_filepath)
+
+
+def getNodeKeyFromFile(nodekey_filepath: str) -> nillion.NodeKey:
+    """
+    Loads node key from file.
+
+    Args:
+        nodekey_filepath (str): Path to node key file.
+
+    Returns:
+        nillion.NodeKey: Node key.
+    """
+    return nillion.NodeKey.from_file(nodekey_filepath)