Proof received:
{proof}
+ {starkProof &&
+
+ <>
+
Proof of work nonce: {starkProof?.commitment_scheme_proof?.proof_of_work?.nonce}
+
+
+ }
diff --git a/askeladd-dvm-marketplace/src/constants/relay.ts b/askeladd-dvm-marketplace/src/constants/relay.ts
new file mode 100644
index 0000000..39d9846
--- /dev/null
+++ b/askeladd-dvm-marketplace/src/constants/relay.ts
@@ -0,0 +1,5 @@
+export const ASKELADD_RELAY= [
+ // DVM service prover deployed need to subscribed to this relays
+ "ws://127.0.0.1:8080", // run in local
+ "wss://relay.nostr.net",
+]
diff --git a/askeladd-dvm-marketplace/src/context/NostrContext.tsx b/askeladd-dvm-marketplace/src/context/NostrContext.tsx
new file mode 100644
index 0000000..b66fcc9
--- /dev/null
+++ b/askeladd-dvm-marketplace/src/context/NostrContext.tsx
@@ -0,0 +1,46 @@
+"use client";
+
+import { ASKELADD_RELAY } from '@/constants/relay';
+import NDK, {NDKPrivateKeySigner} from '@nostr-dev-kit/ndk';
+import {createContext, useContext, useEffect, useState} from 'react';
+import dotenv from "dotenv";
+dotenv.config();
+
+export type NostrContextType = {
+ ndk: NDK;
+};
+
+export const NostrContext = createContext
(null);
+
+export const NostrProvider: React.FC = ({children}) => {
+ const [privateKey, setPrivateKey] = useState(process.env.NEXT_PUBLIC_DEFAULT_NOSTR_USER_SK)
+
+ const [ndk, setNdk] = useState(
+ new NDK({
+ explicitRelayUrls: ASKELADD_RELAY,
+ }),
+ );
+
+ useEffect(() => {
+ const newNdk = new NDK({
+ explicitRelayUrls: ASKELADD_RELAY,
+ signer: privateKey ? new NDKPrivateKeySigner(privateKey) : undefined,
+ });
+
+ newNdk.connect().then(() => {
+ setNdk(newNdk);
+ });
+ }, [privateKey, process.env.DEFAULT_NOSTR_USER_SK]);
+
+ return {children};
+};
+
+export const useNostrContext = () => {
+ const nostr = useContext(NostrContext);
+
+ if (!nostr) {
+ throw new Error('NostrContext must be used within a NostrProvider');
+ }
+
+ return nostr;
+};
diff --git a/askeladd-dvm-marketplace/src/hooks/useFetchEvents.ts b/askeladd-dvm-marketplace/src/hooks/useFetchEvents.ts
new file mode 100644
index 0000000..9c9b8d3
--- /dev/null
+++ b/askeladd-dvm-marketplace/src/hooks/useFetchEvents.ts
@@ -0,0 +1,28 @@
+import { useNostrContext } from '@/context/NostrContext';
+import { NDKEvent, NDKKind } from '@nostr-dev-kit/ndk';
+
+export const useFetchEvents = () => {
+ const { ndk } = useNostrContext();
+ const fetchEvents = async (kind?: NDKKind | number, limit?:number) => {
+ try {
+ if (!ndk?.signer) return { result: undefined, events: undefined };
+ let eventsResult = await ndk.fetchEvents({
+ kinds: [kind ?? 6600 as NDKKind],
+ limit: limit ?? 50,
+ });
+ const events = Array.from(eventsResult?.values())
+ console.log("events", events);
+
+ return {
+ result:undefined,
+ events:events
+ };
+ } catch (e) {
+ return {
+ result:undefined,
+ events:[]
+ };
+ }
+ }
+ return { fetchEvents }
+};
diff --git a/askeladd-dvm-marketplace/src/hooks/useSendNote.ts b/askeladd-dvm-marketplace/src/hooks/useSendNote.ts
new file mode 100644
index 0000000..cd491b0
--- /dev/null
+++ b/askeladd-dvm-marketplace/src/hooks/useSendNote.ts
@@ -0,0 +1,24 @@
+import { useNostrContext } from '@/context/NostrContext';
+import { NDKEvent, NDKKind } from '@nostr-dev-kit/ndk';
+
+export const useSendNote = () => {
+ const { ndk } = useNostrContext();
+ const sendNote = async (data: { content: string; tags?: string[][], kind?: NDKKind | number }) => {
+ try {
+ if (!ndk?.signer) return { result: undefined, event: undefined };
+ const event = new NDKEvent(ndk);
+ event.kind = data?.kind;
+ event.content = data.content;
+ event.tags = data.tags ?? [];
+
+ let result = await event.publish();
+ return { result: result, event };
+ } catch (e) {
+ return {
+ result: undefined,
+ event: undefined
+ }
+ }
+ }
+ return { sendNote }
+};
diff --git a/askeladd-dvm-marketplace/src/hooks/useWasmNostrSDK.ts b/askeladd-dvm-marketplace/src/hooks/useWasmNostrSDK.ts
new file mode 100644
index 0000000..5f53a8d
--- /dev/null
+++ b/askeladd-dvm-marketplace/src/hooks/useWasmNostrSDK.ts
@@ -0,0 +1,44 @@
+import { useEffect, useState } from 'react';
+
+type NostrSDKModule = typeof import('@rust-nostr/nostr-sdk');
+
+/** @TODO fix WASM import => using nostr-dev-kit at this moment */
+export function useWasmNostrSDK() {
+ const [nostrSDK, setNostrSDK] = useState(null);
+ const [error, setError] = useState(null);
+ const [isLoading, setIsLoading] = useState(true);
+
+ useEffect(() => {
+ let isMounted = true;
+
+ async function loadWasmModule() {
+ try {
+ setIsLoading(true);
+ // const { Client, Event, Keys, NostrSigner, Tag, Output, EventId , } = await import('@rust-nostr/nostr-sdk');
+ const sdkModule: NostrSDKModule = await import('@rust-nostr/nostr-sdk');
+
+ const NostrSDK = await import('@rust-nostr/nostr-sdk');
+ if (isMounted) {
+ setNostrSDK(sdkModule);
+ setIsLoading(false);
+ }
+ } catch (err) {
+ if (isMounted) {
+ setError(err as Error);
+ setIsLoading(false);
+ }
+ }
+ }
+
+ // Ensure this is only run on the client
+ if (typeof window !== 'undefined') {
+ loadWasmModule();
+ }
+
+ return () => {
+ isMounted = false;
+ };
+ }, []);
+
+ return { nostrSDK, error, isLoading };
+}
diff --git a/askeladd-dvm-marketplace/src/pkg/package.json b/askeladd-dvm-marketplace/src/pkg/package.json
new file mode 100644
index 0000000..16bb310
--- /dev/null
+++ b/askeladd-dvm-marketplace/src/pkg/package.json
@@ -0,0 +1,15 @@
+{
+ "name": "program_wasm",
+ "type": "module",
+ "version": "0.1.0",
+ "files": [
+ "program_wasm_bg.wasm",
+ "program_wasm.js",
+ "program_wasm.d.ts"
+ ],
+ "main": "program_wasm.js",
+ "types": "program_wasm.d.ts",
+ "sideEffects": [
+ "./snippets/*"
+ ]
+}
\ No newline at end of file
diff --git a/askeladd-dvm-marketplace/src/pkg/program_wasm.d.ts b/askeladd-dvm-marketplace/src/pkg/program_wasm.d.ts
new file mode 100644
index 0000000..a110ee1
--- /dev/null
+++ b/askeladd-dvm-marketplace/src/pkg/program_wasm.d.ts
@@ -0,0 +1,62 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+* @param {number} log_size
+* @param {number} claim
+* @returns {FibonacciResult}
+*/
+export function run_fibonacci_example(log_size: number, claim: number): FibonacciResult;
+/**
+* @param {number} log_size
+* @param {number} claim
+* @param {string} stark_proof_str
+* @returns {FibonacciResult}
+*/
+export function run_fibonacci_verify_exemple(log_size: number, claim: number, stark_proof_str: string): FibonacciResult;
+/**
+*/
+export class FibonacciResult {
+ free(): void;
+/**
+*/
+ readonly message: string;
+/**
+*/
+ readonly success: boolean;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+ readonly memory: WebAssembly.Memory;
+ readonly __wbg_fibonacciresult_free: (a: number) => void;
+ readonly fibonacciresult_success: (a: number) => number;
+ readonly fibonacciresult_message: (a: number, b: number) => void;
+ readonly run_fibonacci_example: (a: number, b: number) => number;
+ readonly run_fibonacci_verify_exemple: (a: number, b: number, c: number, d: number) => number;
+ readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+ readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+ readonly __wbindgen_malloc: (a: number, b: number) => number;
+ readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {SyncInitInput} module
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {InitInput | Promise} module_or_path
+*
+* @returns {Promise}
+*/
+export default function __wbg_init (module_or_path?: InitInput | Promise): Promise;
diff --git a/askeladd-dvm-marketplace/src/pkg/program_wasm.js b/askeladd-dvm-marketplace/src/pkg/program_wasm.js
new file mode 100644
index 0000000..b4cc831
--- /dev/null
+++ b/askeladd-dvm-marketplace/src/pkg/program_wasm.js
@@ -0,0 +1,252 @@
+let wasm;
+
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+ if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+ cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+ }
+ return cachedUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+let cachedInt32Memory0 = null;
+
+function getInt32Memory0() {
+ if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+ cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+ }
+ return cachedInt32Memory0;
+}
+/**
+* @param {number} log_size
+* @param {number} claim
+* @returns {FibonacciResult}
+*/
+export function run_fibonacci_example(log_size, claim) {
+ const ret = wasm.run_fibonacci_example(log_size, claim);
+ return FibonacciResult.__wrap(ret);
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+ ? function (arg, view) {
+ return cachedTextEncoder.encodeInto(arg, view);
+}
+ : function (arg, view) {
+ const buf = cachedTextEncoder.encode(arg);
+ view.set(buf);
+ return {
+ read: arg.length,
+ written: buf.length
+ };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+ if (realloc === undefined) {
+ const buf = cachedTextEncoder.encode(arg);
+ const ptr = malloc(buf.length, 1) >>> 0;
+ getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+ WASM_VECTOR_LEN = buf.length;
+ return ptr;
+ }
+
+ let len = arg.length;
+ let ptr = malloc(len, 1) >>> 0;
+
+ const mem = getUint8Memory0();
+
+ let offset = 0;
+
+ for (; offset < len; offset++) {
+ const code = arg.charCodeAt(offset);
+ if (code > 0x7F) break;
+ mem[ptr + offset] = code;
+ }
+
+ if (offset !== len) {
+ if (offset !== 0) {
+ arg = arg.slice(offset);
+ }
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+ const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+ const ret = encodeString(arg, view);
+
+ offset += ret.written;
+ ptr = realloc(ptr, len, offset, 1) >>> 0;
+ }
+
+ WASM_VECTOR_LEN = offset;
+ return ptr;
+}
+/**
+* @param {number} log_size
+* @param {number} claim
+* @param {string} stark_proof_str
+* @returns {FibonacciResult}
+*/
+export function run_fibonacci_verify_exemple(log_size, claim, stark_proof_str) {
+ const ptr0 = passStringToWasm0(stark_proof_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len0 = WASM_VECTOR_LEN;
+ const ret = wasm.run_fibonacci_verify_exemple(log_size, claim, ptr0, len0);
+ return FibonacciResult.__wrap(ret);
+}
+
+const FibonacciResultFinalization = (typeof FinalizationRegistry === 'undefined')
+ ? { register: () => {}, unregister: () => {} }
+ : new FinalizationRegistry(ptr => wasm.__wbg_fibonacciresult_free(ptr >>> 0));
+/**
+*/
+export class FibonacciResult {
+
+ static __wrap(ptr) {
+ ptr = ptr >>> 0;
+ const obj = Object.create(FibonacciResult.prototype);
+ obj.__wbg_ptr = ptr;
+ FibonacciResultFinalization.register(obj, obj.__wbg_ptr, obj);
+ return obj;
+ }
+
+ __destroy_into_raw() {
+ const ptr = this.__wbg_ptr;
+ this.__wbg_ptr = 0;
+ FibonacciResultFinalization.unregister(this);
+ return ptr;
+ }
+
+ free() {
+ const ptr = this.__destroy_into_raw();
+ wasm.__wbg_fibonacciresult_free(ptr);
+ }
+ /**
+ * @returns {boolean}
+ */
+ get success() {
+ const ret = wasm.fibonacciresult_success(this.__wbg_ptr);
+ return ret !== 0;
+ }
+ /**
+ * @returns {string}
+ */
+ get message() {
+ let deferred1_0;
+ let deferred1_1;
+ try {
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+ wasm.fibonacciresult_message(retptr, this.__wbg_ptr);
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
+ deferred1_0 = r0;
+ deferred1_1 = r1;
+ return getStringFromWasm0(r0, r1);
+ } finally {
+ wasm.__wbindgen_add_to_stack_pointer(16);
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+ }
+ }
+}
+
+async function __wbg_load(module, imports) {
+ if (typeof Response === 'function' && module instanceof Response) {
+ if (typeof WebAssembly.instantiateStreaming === 'function') {
+ try {
+ return await WebAssembly.instantiateStreaming(module, imports);
+
+ } catch (e) {
+ if (module.headers.get('Content-Type') != 'application/wasm') {
+ console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+ } else {
+ throw e;
+ }
+ }
+ }
+
+ const bytes = await module.arrayBuffer();
+ return await WebAssembly.instantiate(bytes, imports);
+
+ } else {
+ const instance = await WebAssembly.instantiate(module, imports);
+
+ if (instance instanceof WebAssembly.Instance) {
+ return { instance, module };
+
+ } else {
+ return instance;
+ }
+ }
+}
+
+function __wbg_get_imports() {
+ const imports = {};
+ imports.wbg = {};
+ imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+ throw new Error(getStringFromWasm0(arg0, arg1));
+ };
+
+ return imports;
+}
+
+function __wbg_init_memory(imports, maybe_memory) {
+
+}
+
+function __wbg_finalize_init(instance, module) {
+ wasm = instance.exports;
+ __wbg_init.__wbindgen_wasm_module = module;
+ cachedInt32Memory0 = null;
+ cachedUint8Memory0 = null;
+
+
+ return wasm;
+}
+
+function initSync(module) {
+ if (wasm !== undefined) return wasm;
+
+ const imports = __wbg_get_imports();
+
+ __wbg_init_memory(imports);
+
+ if (!(module instanceof WebAssembly.Module)) {
+ module = new WebAssembly.Module(module);
+ }
+
+ const instance = new WebAssembly.Instance(module, imports);
+
+ return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(input) {
+ if (wasm !== undefined) return wasm;
+
+ if (typeof input === 'undefined') {
+ input = new URL('program_wasm_bg.wasm', import.meta.url);
+ }
+ const imports = __wbg_get_imports();
+
+ if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
+ input = fetch(input);
+ }
+
+ __wbg_init_memory(imports);
+
+ const { instance, module } = await __wbg_load(await input, imports);
+
+ return __wbg_finalize_init(instance, module);
+}
+
+export { initSync }
+export default __wbg_init;
diff --git a/askeladd-dvm-marketplace/src/pkg/program_wasm_bg.wasm b/askeladd-dvm-marketplace/src/pkg/program_wasm_bg.wasm
new file mode 100644
index 0000000..e99d2ed
Binary files /dev/null and b/askeladd-dvm-marketplace/src/pkg/program_wasm_bg.wasm differ
diff --git a/askeladd-dvm-marketplace/src/pkg/program_wasm_bg.wasm.d.ts b/askeladd-dvm-marketplace/src/pkg/program_wasm_bg.wasm.d.ts
new file mode 100644
index 0000000..d6129db
--- /dev/null
+++ b/askeladd-dvm-marketplace/src/pkg/program_wasm_bg.wasm.d.ts
@@ -0,0 +1,12 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export function __wbg_fibonacciresult_free(a: number): void;
+export function fibonacciresult_success(a: number): number;
+export function fibonacciresult_message(a: number, b: number): void;
+export function run_fibonacci_example(a: number, b: number): number;
+export function run_fibonacci_verify_exemple(a: number, b: number, c: number, d: number): number;
+export function __wbindgen_add_to_stack_pointer(a: number): number;
+export function __wbindgen_free(a: number, b: number, c: number): void;
+export function __wbindgen_malloc(a: number, b: number): number;
+export function __wbindgen_realloc(a: number, b: number, c: number, d: number): number;
diff --git a/askeladd-dvm-marketplace/src/types/index.ts b/askeladd-dvm-marketplace/src/types/index.ts
new file mode 100644
index 0000000..5d9baaf
--- /dev/null
+++ b/askeladd-dvm-marketplace/src/types/index.ts
@@ -0,0 +1,32 @@
+export interface JobResultProver {
+ job_id:string;
+ response: {
+ // params in a JSON object
+
+ // proof
+ proof:any
+ // proof:StarkProof
+ }
+}
+
+export interface StarkProof {
+ commitments:string[];
+ lookup_values:Map;
+ commitment_scheme_proof:CommitmentSchemeProof
+}
+
+/** @TODO finish to implement correctly */
+export interface CommitmentSchemeProof {
+ sampled_values:string[];
+ decommitments:string[];
+ queried_values:string[];
+ proof_of_work:{
+ nonce:string
+ };
+ fri_proof:{
+ inner_layers:{evals_subset:number[][][], }[]
+ decommitment:{
+ hash_witness:number[][]
+ }
+ };
+}
diff --git a/askeladd-dvm-marketplace/tsconfig.json b/askeladd-dvm-marketplace/tsconfig.json
index 7b28589..ed4e6db 100644
--- a/askeladd-dvm-marketplace/tsconfig.json
+++ b/askeladd-dvm-marketplace/tsconfig.json
@@ -1,5 +1,6 @@
{
"compilerOptions": {
+ "target": "ESNext",
"lib": ["dom", "dom.iterable", "esnext"],
"allowJs": true,
"skipLibCheck": true,
@@ -21,6 +22,6 @@
"@/*": ["./src/*"]
}
},
- "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+ "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts", "**/*wasm"],
"exclude": ["node_modules"]
}
diff --git a/config/default.toml b/config/default.toml
index b8292aa..c02200f 100644
--- a/config/default.toml
+++ b/config/default.toml
@@ -3,3 +3,4 @@ proving_req_sub_id = "askeladd.proving.request"
proving_resp_sub_id = "askeladd.proving.response"
user_bech32_sk = "nsec1tsaxyqcxp8atqup4facwp0as52f2c0evj4cxpw6yaqetusu7sg8qqzkr3k"
prover_agent_sk = "nsec18s6wcqlkglhjmfz3tnjkh0qscf6cqen96ecp5k5k73ktew3l97tstuvy2x"
+prover_agent_pk = "npub1w0an6lqax8pa32x38tf7lufn50fzv3cwx6nrjjxtm9yfkl94rleqxrvdxc"
diff --git a/crates/program_wasm/Cargo.toml b/crates/program_wasm/Cargo.toml
new file mode 100644
index 0000000..b891715
--- /dev/null
+++ b/crates/program_wasm/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "program_wasm"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+stwo-prover = { git = "https://github.com/starkware-libs/stwo.git" }
+wasm-bindgen = "0.2.84"
+serde_json = "1.0.121"
+getrandom = { version = "0.2", features = ["js"] }
+
+[dev-dependencies]
+wasm-bindgen-test = "0.3.34"
+
+[package.metadata.wasm-pack.profile.release]
+wasm-opt = false
diff --git a/crates/program_wasm/src/fibonacci.rs b/crates/program_wasm/src/fibonacci.rs
new file mode 100644
index 0000000..7c1b70b
--- /dev/null
+++ b/crates/program_wasm/src/fibonacci.rs
@@ -0,0 +1,68 @@
+use serde_json;
+use stwo_prover::core::fields::m31::BaseField;
+use stwo_prover::core::prover::StarkProof;
+use stwo_prover::examples::fibonacci::Fibonacci;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub struct FibonacciResult {
+ success: bool,
+ message: String,
+}
+
+#[wasm_bindgen]
+impl FibonacciResult {
+ #[wasm_bindgen(getter)]
+ pub fn success(&self) -> bool {
+ self.success
+ }
+
+ #[wasm_bindgen(getter)]
+ pub fn message(&self) -> String {
+ self.message.clone()
+ }
+}
+
+#[wasm_bindgen]
+pub fn run_fibonacci_example(log_size: u32, claim: u32) -> FibonacciResult {
+ let fib = Fibonacci::new(log_size, BaseField::from(claim));
+
+ match fib.prove() {
+ Ok(proof) => match fib.verify(proof) {
+ Ok(_) => FibonacciResult {
+ success: true,
+ message: "Proof generated and verified successfully".to_string(),
+ },
+ Err(e) => FibonacciResult {
+ success: false,
+ message: format!("Proof verification failed: {:?}", e),
+ },
+ },
+ Err(e) => FibonacciResult {
+ success: false,
+ message: format!("Proof generation failed: {:?}", e),
+ },
+ }
+}
+
+#[wasm_bindgen]
+pub fn run_fibonacci_verify_exemple(
+ log_size: u32,
+ claim: u32,
+ stark_proof_str: &str,
+) -> FibonacciResult {
+ let fib = Fibonacci::new(log_size, BaseField::from(claim));
+
+ let stark_proof: StarkProof = serde_json::from_str(stark_proof_str).unwrap();
+
+ match fib.verify(stark_proof) {
+ Ok(()) => FibonacciResult {
+ success: true,
+ message: "Proof generated and verified successfully".to_string(),
+ },
+ Err(e) => FibonacciResult {
+ success: false,
+ message: format!("Proof generation failed: {:?}", e),
+ },
+ }
+}
diff --git a/crates/program_wasm/src/lib.rs b/crates/program_wasm/src/lib.rs
new file mode 100644
index 0000000..834a3d0
--- /dev/null
+++ b/crates/program_wasm/src/lib.rs
@@ -0,0 +1 @@
+pub mod fibonacci;