Refactoring shared code into shared folder

rust-toolchain.toml

@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2024-05-14"
+channel = "nightly-2024-07-21"
 components = [ "rust-std", "rust-src" ]
 targets = [ "wasm32-unknown-unknown" ]

sdk/package.json

@@ -7,12 +7,20 @@
   ],
   "license": "GPL-3.0",
   "type": "module",
-  "main": "./dist/node.js",
-  "browser": "./dist/index.js",
+  "main": "./dist/testnet/node.js",
+  "browser": "./dist/testnet/browser.js",
   "exports": {
     ".": {
-      "node": "./dist/node.js",
-      "default": "./dist/index.js"
+      "node": "./dist/testnet/node.js",
+      "default": "./dist/testnet/browser.js"
+    },
+    "./testnet.js": {
+      "node": "./dist/testnet/node.js",
+      "default": "./dist/testnet/browser.js"
+    },
+    "./mainnet.js": {
+      "node": "./dist/mainnet/node.js",
+      "default": "./dist/mainnet/browser.js"
     }
   },
   "files": [

sdk/rollup.config.js

@@ -4,10 +4,10 @@ import $package from "./package.json" assert { type: "json" };
 
 export default {
     input: {
-        index: "./src/index.ts",
-        worker: "./src/worker.ts",
-        node: "./src/node.ts",
-        "node-polyfill": "./src/node-polyfill.ts",
+        "testnet/browser": "./src/testnet/browser.ts",
+        "testnet/worker": "./src/shared/worker.ts",
+        "testnet/node": "./src/testnet/node.ts",
+        "node-polyfill": "./src/shared/node-polyfill.ts",
     },
     output: {
         dir: `dist`,

sdk/src/index.ts → sdk/src/shared/index.ts

@@ -1,4 +1,4 @@
-import {VerifyingKey, Metadata} from "@provablehq/wasm";
+import {VerifyingKey, Metadata} from "@provablehq/wasm/testnet.js";
 
 const KEY_STORE = Metadata.baseUrl();
 
@@ -158,7 +158,7 @@ export {
     ViewKey,
     initThreadPool,
     verifyFunctionExecution,
-} from "@provablehq/wasm";
+} from "@provablehq/wasm/testnet.js";
 
 export { initializeWasm };
 

sdk/src/program-manager.ts → sdk/src/shared/program-manager.ts

@@ -21,7 +21,7 @@ import {
     logAndThrow,
     ProgramManagerBase as WasmProgramManager, verifyFunctionExecution, AleoKeyProviderParams, CREDITS_PROGRAM_KEYS,
 } from "./index";
-import {Execution} from "@provablehq/wasm/dist/crates/aleo_wasm";
+import {Execution} from "@provablehq/wasm/testnet.js";
 
 /**
  * Represents the options for executing a transaction in the Aleo network.
@@ -78,7 +78,7 @@ class ProgramManager {
     constructor(host?: string | undefined, keyProvider?: FunctionKeyProvider | undefined, recordProvider?: RecordProvider | undefined) {
         this.host = host ? host : 'https://api.explorer.aleo.org/v1';
         this.networkClient = new AleoNetworkClient(this.host);
-        
+
         this.keyProvider = keyProvider ? keyProvider : new AleoKeyProvider();
         this.recordProvider = recordProvider;
     }

sdk/src/shared/worker.ts

@@ -0,0 +1,146 @@
+import type { FunctionKeyPair } from "./function-key-provider";
+import { ProgramManager } from "./program-manager";
+import { AleoKeyProvider, AleoKeyProviderParams} from "./function-key-provider";
+import { expose } from "comlink";
+
+
+export interface WorkerAPI {
+    executeOffline: (
+        localProgram: string,
+        aleoFunction: string,
+        inputs: string[],
+        privateKey: string
+    ) => Promise<{ outputs: any; execution: string } | string>;
+
+    getPrivateKey: () => Promise<any>;
+}
+
+
+export abstract class WorkerImpl {
+    abstract from_string(key: string): any;
+
+    abstract to_string(): string;
+
+    abstract verifyFunctionExecution(execution: any, verifying_key: any, program: any, function_id: string): boolean;
+
+    init() {
+        const defaultHost = "https://api.explorer.aleo.org/v1";
+        const keyProvider = new AleoKeyProvider();
+        const programManager = new ProgramManager(
+            defaultHost,
+            keyProvider,
+            undefined
+        );
+
+        keyProvider.useCache(true);
+
+        let lastLocalProgram: string = "";
+
+        const executeOffline = async (
+            localProgram: string,
+            aleoFunction: string,
+            inputs: string[],
+            privateKey: string,
+            proveExecution = false
+        ) => {
+            console.log("Web worker: Executing function locally...");
+            const startTime = performance.now();
+
+            try {
+                // Ensure the program is valid and that it contains the function specified
+                const program = programManager.createProgramFromSource(localProgram);
+                if (program instanceof Error) {
+                    throw "Error creating program from source";
+                }
+                const program_id = program.id();
+                if (!program.hasFunction(aleoFunction)) {
+                    throw `Program ${program_id} does not contain function ${aleoFunction}`;
+                }
+                const cacheKey = `${program_id}:${aleoFunction}`;
+
+                // Get the program imports
+                const imports = await programManager.networkClient.getProgramImports(
+                    localProgram
+                );
+
+                if (imports instanceof Error) {
+                    throw "Error getting program imports";
+                }
+                // Get the proving and verifying keys for the function
+                if (lastLocalProgram !== localProgram) {
+                    const keys = <FunctionKeyPair>await programManager.synthesizeKeys(
+                        localProgram,
+                        aleoFunction,
+                        inputs,
+                        this.from_string(privateKey)
+                    );
+                    programManager.keyProvider.cacheKeys(cacheKey, keys);
+                    lastLocalProgram = localProgram;
+                }
+
+                // Pass the cache key to the execute function
+                const keyParams = new AleoKeyProviderParams({
+                    cacheKey: cacheKey,
+                });
+
+                // Execute the function locally
+                const response = await programManager.run(
+                    localProgram,
+                    aleoFunction,
+                    inputs,
+                    proveExecution,
+                    imports,
+                    keyParams,
+                    undefined,
+                    undefined,
+                    this.from_string(privateKey),
+                );
+
+                // Return the outputs to the main thread
+                console.log(
+                    `Web worker: Local execution completed in ${
+                        performance.now() - startTime
+                    } ms`
+                );
+                const outputs = response.getOutputs();
+                const execution = response.getExecution();
+                let executionString = "";
+
+                const keys = keyProvider.getKeys(cacheKey);
+
+                if (keys instanceof Error) {
+                    throw "Could not get verifying key";
+                }
+
+                const verifyingKey = keys[1];
+
+                if (execution) {
+                    this.verifyFunctionExecution(
+                        execution,
+                        verifyingKey,
+                        program,
+                        "hello"
+                    );
+                    executionString = execution.toString();
+                    console.log("Execution verified successfully: " + execution);
+                } else {
+                    executionString = "";
+                }
+
+                console.log(`Function execution response: ${outputs}`);
+
+                return { outputs: outputs, execution: executionString };
+            } catch (error) {
+                console.error(error);
+                return error ? error.toString() : "Unknown error";
+            }
+        }
+
+        const getPrivateKey = async () => {
+            return this.to_string();
+        };
+
+        const workerAPI = { executeOffline, getPrivateKey };
+        expose(workerAPI);
+    }
+}