Adding in dynamic loadNetwork function

Author: Pauan

.circleci/config.yml

@@ -93,6 +93,15 @@ jobs:
           command: |
             yarn start
 
+  e2e-dynamic:
+    executor: rust-node
+    steps:
+      - setup-sdk
+      - run:
+          working_directory: e2e/dynamic
+          command: |
+            yarn start
+
   create-leo-app-cli:
     executor: rust-node
     steps:
@@ -181,6 +190,9 @@ workflows:
       - e2e-mainnet:
           requires:
             - sdk
+      - e2e-dynamic:
+          requires:
+            - sdk
       - create-leo-app-cli:
           requires:
             - sdk

e2e/dynamic/index.js

@@ -0,0 +1,62 @@
+import { loadNetwork } from "@provablehq/sdk/dynamic.js";
+
+const mainnet = await loadNetwork("mainnet");
+
+await mainnet.initThreadPool();
+
+const programName = "hello_hello.aleo"
+
+const hello_hello_program =`
+program ${programName};
+
+function hello:
+    input r0 as u32.public;
+    input r1 as u32.private;
+    add r0 r1 into r2;
+    output r2 as u32.private;`
+
+async function localProgramExecution(program, programName, aleoFunction, inputs) {
+    const programManager = new mainnet.ProgramManager();
+
+    // Create a temporary account for the execution of the program
+    const account = new mainnet.Account();
+    programManager.setAccount(account);
+
+    // Create a key provider in order to re-use the same key for each execution
+    const keyProvider = new mainnet.AleoKeyProvider();
+    keyProvider.useCache(true);
+    programManager.setKeyProvider(keyProvider);
+
+    // Pre-synthesize the program keys and then cache them in memory using key provider
+    const keyPair = await programManager.synthesizeKeys(hello_hello_program, aleoFunction, inputs);
+    programManager.keyProvider.cacheKeys(`${programName}:${aleoFunction}`, keyPair);
+
+    // Specify parameters for the key provider to use search for program keys. In particular specify the cache key
+    // that was used to cache the keys in the previous step.
+    const keyProviderParams = new mainnet.AleoKeyProviderParams({cacheKey: `${programName}:${aleoFunction}`});
+
+    // Execute once using the key provider params defined above. This will use the cached proving keys and make
+    // execution significantly faster.
+    let executionResponse = await programManager.run(
+        program,
+        aleoFunction,
+        inputs,
+        true,
+        undefined,
+        keyProviderParams,
+    );
+    console.log("hello_hello/hello executed - result:", executionResponse.getOutputs());
+
+    // Verify the execution using the verifying key that was generated earlier.
+    const blockHeight = 9_000_000;
+    if (programManager.verifyExecution(executionResponse, blockHeight)) {
+        console.log("hello_hello/hello execution verified!");
+    } else {
+        throw("Execution failed verification!");
+    }
+}
+
+const start = Date.now();
+console.log("Starting execute!");
+await localProgramExecution(hello_hello_program, programName, "hello", ["5u32", "5u32"]);
+console.log("Execute finished!", Date.now() - start);

e2e/dynamic/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "e2e-dynamic",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "@provablehq/sdk": "^0.9.10-testnet-rc"
+  }
+}

sdk/package.json

@@ -21,6 +21,10 @@
     "./mainnet.js": {
       "node": "./dist/mainnet/node.js",
       "default": "./dist/mainnet/browser.js"
+    },
+    "./dynamic.js": {
+      "node": "./dist/dynamic/node.js",
+      "default": "./dist/dynamic/browser.js"
     }
   },
   "files": [

sdk/rollup.config.js

@@ -1,3 +1,5 @@
+import * as $fs from "node:fs/promises";
+import * as $path from "node:path";
 import typescript from "rollup-plugin-typescript2";
 import replace from "@rollup/plugin-replace";
 import $package from "./package.json" with { type: "json" };
@@ -7,7 +9,12 @@ const networks = [
     "mainnet",
 ];
 
-export default networks.map((network) => {
+const runtimes = [
+    "browser",
+    "node",
+];
+
+function buildNetwork(network) {
     return {
         input: {
             "node-polyfill": "./src/node-polyfill.ts",
@@ -49,4 +56,36 @@ export default networks.map((network) => {
             }),
         ],
     };
-});
+}
+
+async function buildRuntimes() {
+    await Promise.all(runtimes.map(async (runtime) => {
+        await $fs.mkdir(`dist/dynamic`, { recursive: true });
+
+        const loading = networks.map((network) => `"${network}": () => import("../${network}/${runtime}.js"),`).join("\n    ");
+
+        const typings = networks.map((network) => `"${network}": typeof import("../${network}/${runtime}"),`).join("\n    ");
+
+        await $fs.writeFile(`dist/dynamic/${runtime}.js`, `const networks = {
+    ${loading}
+};
+
+export function loadNetwork(name) {
+    return networks[name]();
+}
+`);
+
+        await $fs.writeFile(`dist/dynamic/${runtime}.d.ts`, `interface Networks {
+    ${typings}
+}
+
+export { Networks };
+
+export declare function loadNetwork<Key extends keyof Networks>(name: Key): Promise<Networks[Key]>;
+`);
+    }));
+}
+
+await buildRuntimes();
+
+export default networks.map(buildNetwork);