create-leo-app 0.9.3 → 0.9.4

package/template-react-ts/node_modules/undici-types/util.d.ts

@@ -0,0 +1,18 @@
+export namespace util {
+  /**
+   * Retrieves a header name and returns its lowercase value.
+   * @param value Header name
+   */
+  export function headerNameToString(value: string | Buffer): string;
+
+  /**
+   * Receives a header object and returns the parsed value.
+   * @param headers Header object
+   * @param obj Object to specify a proxy object. Used to assign parsed values.
+   * @returns If `obj` is specified, it is equivalent to `obj`.
+   */
+  export function parseHeaders(
+    headers: (Buffer | string | (Buffer | string)[])[],
+    obj?: Record<string, string | string[]>
+  ): Record<string, string | string[]>;
+}

package/template-react-ts/node_modules/undici-types/webidl.d.ts

@@ -0,0 +1,228 @@
+// These types are not exported, and are only used internally
+
+/**
+ * Take in an unknown value and return one that is of type T
+ */
+type Converter<T> = (object: unknown) => T
+
+type SequenceConverter<T> = (object: unknown, iterable?: IterableIterator<T>) => T[]
+
+type RecordConverter<K extends string, V> = (object: unknown) => Record<K, V>
+
+interface ConvertToIntOpts {
+  clamp?: boolean
+  enforceRange?: boolean
+}
+
+interface WebidlErrors {
+  exception (opts: { header: string, message: string }): TypeError
+  /**
+   * @description Throw an error when conversion from one type to another has failed
+   */
+  conversionFailed (opts: {
+    prefix: string
+    argument: string
+    types: string[]
+  }): TypeError
+  /**
+   * @description Throw an error when an invalid argument is provided
+   */
+  invalidArgument (opts: {
+    prefix: string
+    value: string
+    type: string
+  }): TypeError
+}
+
+interface WebidlUtil {
+  /**
+   * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
+   */
+  Type (object: unknown):
+    | 'Undefined'
+    | 'Boolean'
+    | 'String'
+    | 'Symbol'
+    | 'Number'
+    | 'BigInt'
+    | 'Null'
+    | 'Object'
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+   */
+  ConvertToInt (
+    V: unknown,
+    bitLength: number,
+    signedness: 'signed' | 'unsigned',
+    opts?: ConvertToIntOpts
+  ): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+   */
+  IntegerPart (N: number): number
+
+  /**
+   * Stringifies {@param V}
+   */
+  Stringify (V: any): string
+
+  /**
+   * Mark a value as uncloneable for Node.js.
+   * This is only effective in some newer Node.js versions.
+   */
+  markAsUncloneable (V: any): void
+}
+
+interface WebidlConverters {
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-DOMString
+   */
+  DOMString (V: unknown, prefix: string, argument: string, opts?: {
+    legacyNullToEmptyString: boolean
+  }): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-ByteString
+   */
+  ByteString (V: unknown, prefix: string, argument: string): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-USVString
+   */
+  USVString (V: unknown): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-boolean
+   */
+  boolean (V: unknown): boolean
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-any
+   */
+  any <Value>(V: Value): Value
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-long-long
+   */
+  ['long long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-long-long
+   */
+  ['unsigned long long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-long
+   */
+  ['unsigned long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-short
+   */
+  ['unsigned short'] (V: unknown, opts?: ConvertToIntOpts): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#idl-ArrayBuffer
+   */
+  ArrayBuffer (V: unknown): ArrayBufferLike
+  ArrayBuffer (V: unknown, opts: { allowShared: false }): ArrayBuffer
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
+   */
+  TypedArray (
+    V: unknown,
+    TypedArray: NodeJS.TypedArray | ArrayBufferLike
+  ): NodeJS.TypedArray | ArrayBufferLike
+  TypedArray (
+    V: unknown,
+    TypedArray: NodeJS.TypedArray | ArrayBufferLike,
+    opts?: { allowShared: false }
+  ): NodeJS.TypedArray | ArrayBuffer
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
+   */
+  DataView (V: unknown, opts?: { allowShared: boolean }): DataView
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#BufferSource
+   */
+  BufferSource (
+    V: unknown,
+    opts?: { allowShared: boolean }
+  ): NodeJS.TypedArray | ArrayBufferLike | DataView
+
+  ['sequence<ByteString>']: SequenceConverter<string>
+  
+  ['sequence<sequence<ByteString>>']: SequenceConverter<string[]>
+
+  ['record<ByteString, ByteString>']: RecordConverter<string, string>
+
+  [Key: string]: (...args: any[]) => unknown
+}
+
+export interface Webidl {
+  errors: WebidlErrors
+  util: WebidlUtil
+  converters: WebidlConverters
+
+  /**
+   * @description Performs a brand-check on {@param V} to ensure it is a
+   * {@param cls} object.
+   */
+  brandCheck <Interface>(V: unknown, cls: Interface, opts?: { strict?: boolean }): asserts V is Interface
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-sequence
+   * @description Convert a value, V, to a WebIDL sequence type.
+   */
+  sequenceConverter <Type>(C: Converter<Type>): SequenceConverter<Type>
+
+  illegalConstructor (): never
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-to-record
+   * @description Convert a value, V, to a WebIDL record type.
+   */
+  recordConverter <K extends string, V>(
+    keyConverter: Converter<K>,
+    valueConverter: Converter<V>
+  ): RecordConverter<K, V>
+
+  /**
+   * Similar to {@link Webidl.brandCheck} but allows skipping the check if third party
+   * interfaces are allowed.
+   */
+  interfaceConverter <Interface>(cls: Interface): (
+    V: unknown,
+    opts?: { strict: boolean }
+  ) => asserts V is typeof cls
+
+  // TODO(@KhafraDev): a type could likely be implemented that can infer the return type
+  // from the converters given?
+  /**
+   * Converts a value, V, to a WebIDL dictionary types. Allows limiting which keys are
+   * allowed, values allowed, optional and required keys. Auto converts the value to
+   * a type given a converter.
+   */
+  dictionaryConverter (converters: {
+    key: string,
+    defaultValue?: () => unknown,
+    required?: boolean,
+    converter: (...args: unknown[]) => unknown,
+    allowedValues?: unknown[]
+  }[]): (V: unknown) => Record<string, unknown>
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#idl-nullable-type
+   * @description allows a type, V, to be null
+   */
+  nullableConverter <T>(
+    converter: Converter<T>
+  ): (V: unknown) => ReturnType<typeof converter> | null
+
+  argumentLengthCheck (args: { length: number }, min: number, context: string): void
+}

package/template-react-ts/node_modules/undici-types/websocket.d.ts

@@ -0,0 +1,150 @@
+/// <reference types="node" />
+
+import type { Blob } from 'buffer'
+import type { MessagePort } from 'worker_threads'
+import {
+  EventInit,
+  EventListenerOptions,
+  AddEventListenerOptions,
+  EventListenerOrEventListenerObject
+} from './patch'
+import Dispatcher from './dispatcher'
+import { HeadersInit } from './fetch'
+
+export type BinaryType = 'blob' | 'arraybuffer'
+
+interface WebSocketEventMap {
+  close: CloseEvent
+  error: ErrorEvent
+  message: MessageEvent
+  open: Event
+}
+
+interface WebSocket extends EventTarget {
+  binaryType: BinaryType
+  
+  readonly bufferedAmount: number
+  readonly extensions: string
+
+  onclose: ((this: WebSocket, ev: WebSocketEventMap['close']) => any) | null
+  onerror: ((this: WebSocket, ev: WebSocketEventMap['error']) => any) | null
+  onmessage: ((this: WebSocket, ev: WebSocketEventMap['message']) => any) | null
+  onopen: ((this: WebSocket, ev: WebSocketEventMap['open']) => any) | null
+
+  readonly protocol: string
+  readonly readyState: number
+  readonly url: string
+
+  close(code?: number, reason?: string): void
+  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void
+
+  readonly CLOSED: number
+  readonly CLOSING: number
+  readonly CONNECTING: number
+  readonly OPEN: number
+
+  addEventListener<K extends keyof WebSocketEventMap>(
+    type: K,
+    listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  removeEventListener<K extends keyof WebSocketEventMap>(
+    type: K,
+    listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
+    options?: boolean | EventListenerOptions
+  ): void
+  removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | EventListenerOptions
+  ): void
+}
+
+export declare const WebSocket: {
+  prototype: WebSocket
+  new (url: string | URL, protocols?: string | string[] | WebSocketInit): WebSocket
+  readonly CLOSED: number
+  readonly CLOSING: number
+  readonly CONNECTING: number
+  readonly OPEN: number
+}
+
+interface CloseEventInit extends EventInit {
+  code?: number
+  reason?: string
+  wasClean?: boolean
+}
+
+interface CloseEvent extends Event {
+  readonly code: number
+  readonly reason: string
+  readonly wasClean: boolean
+}
+
+export declare const CloseEvent: {
+  prototype: CloseEvent
+  new (type: string, eventInitDict?: CloseEventInit): CloseEvent
+}
+
+interface MessageEventInit<T = any> extends EventInit {
+  data?: T
+  lastEventId?: string
+  origin?: string
+  ports?: (typeof MessagePort)[]
+  source?: typeof MessagePort | null
+}
+
+interface MessageEvent<T = any> extends Event {
+  readonly data: T
+  readonly lastEventId: string
+  readonly origin: string
+  readonly ports: ReadonlyArray<typeof MessagePort>
+  readonly source: typeof MessagePort | null
+  initMessageEvent(
+    type: string,
+    bubbles?: boolean,
+    cancelable?: boolean,
+    data?: any,
+    origin?: string,
+    lastEventId?: string,
+    source?: typeof MessagePort | null,
+    ports?: (typeof MessagePort)[]
+  ): void;
+}
+
+export declare const MessageEvent: {
+  prototype: MessageEvent
+  new<T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>
+}
+
+interface ErrorEventInit extends EventInit {
+  message?: string
+  filename?: string
+  lineno?: number
+  colno?: number
+  error?: any
+}
+
+interface ErrorEvent extends Event {
+  readonly message: string
+  readonly filename: string
+  readonly lineno: number
+  readonly colno: number
+  readonly error: any
+}
+
+export declare const ErrorEvent: {
+  prototype: ErrorEvent
+  new (type: string, eventInitDict?: ErrorEventInit): ErrorEvent
+}
+
+interface WebSocketInit {
+  protocols?: string | string[],
+  dispatcher?: Dispatcher,
+  headers?: HeadersInit
+}

package/template-react-ts/package.json

@@ -12,7 +12,7 @@
     "install-leo": "./install.sh"
   },
   "dependencies": {
-    "@provablehq/sdk": "^0.9.3",
+    "@provablehq/sdk": "^0.9.4",
     "comlink": "^4.4.2",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"

package/template-vanilla/package.json

@@ -9,7 +9,7 @@
         "preview": "vite preview"
     },
     "devDependencies": {
-        "@provablehq/sdk": "^0.9.3",
+        "@provablehq/sdk": "^0.9.4",
         "tslib": "^2.8.1",
         "vite": "^6.1.2"
     }

package/template-offline-public-transaction-ts/dist/index.js

@@ -1,195 +0,0 @@
-import { CREDITS_PROGRAM_KEYS, initThreadPool, Account, ProgramManager, ProvingKey, OfflineKeyProvider, OfflineQuery, OfflineSearchParams } from '@provablehq/sdk';
-import { promises, writeFileSync } from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-async function downloadAndSaveKey(keyData, keysDirPath) {
-    const locatorParts = keyData.locator.split('/');
-    const fileName = locatorParts.pop();
-    const dirPath = path.join(keysDirPath, ...locatorParts);
-    await promises.mkdir(dirPath, { recursive: true });
-    const filePath = path.join(dirPath, `${fileName}.prover`);
-    try {
-        await promises.access(filePath);
-        return filePath;
-    }
-    catch (_a) {
-        const res = await fetch(keyData.prover);
-        const buffer = await res.arrayBuffer();
-        writeFileSync(filePath, new Uint8Array(buffer), { flag: 'wx' });
-        console.log(`Downloaded ${keyData.locator}.prover to ${filePath}`);
-        return filePath;
-    }
-}
-async function preDownloadTransferKeys() {
-    const keyPaths = {};
-    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    const keysDirPath = path.join(__dirname, "keys");
-    await promises.mkdir(keysDirPath, { recursive: true });
-    for (const keyData of [CREDITS_PROGRAM_KEYS.transfer_public, CREDITS_PROGRAM_KEYS.fee_public, CREDITS_PROGRAM_KEYS.transfer_public_as_signer]) {
-        try {
-            keyPaths[keyData.locator] = await downloadAndSaveKey(keyData, keysDirPath);
-        }
-        catch (error) {
-            throw (`Failed to download ${keyData.locator} - ${error}`);
-        }
-    }
-    return keyPaths;
-}
-async function preDownloadBondingKeys() {
-    const keyPaths = {};
-    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    const keysDirPath = path.join(__dirname, "keys");
-    await promises.mkdir(keysDirPath, { recursive: true });
-    for (const keyData of [CREDITS_PROGRAM_KEYS.bond_public, CREDITS_PROGRAM_KEYS.fee_public, CREDITS_PROGRAM_KEYS.unbond_public, CREDITS_PROGRAM_KEYS.claim_unbond_public]) {
-        try {
-            keyPaths[keyData.locator] = await downloadAndSaveKey(keyData, keysDirPath);
-        }
-        catch (error) {
-            throw (`Failed to download ${keyData.locator} - ${error}`);
-        }
-    }
-    return keyPaths;
-}
-async function getLocalKey(filePath) {
-    try {
-        console.log("Reading key file:", filePath);
-        const buffer = await promises.readFile(filePath);
-        return new Uint8Array(buffer);
-    }
-    catch (error) {
-        console.error("Error reading file:", error);
-        throw error;
-    }
-}
-
-await initThreadPool();
-/// Build transfer public transaction without connection to the internet
-async function buildTransferPublicTxOffline(recipientAddress, amount, latestStateRoot, keyPaths) {
-    // Create an offline program manager
-    const programManager = new ProgramManager();
-    // Create a temporary account for the execution of the program
-    const account = new Account();
-    programManager.setAccount(account);
-    // Create the proving keys from the key bytes on the offline machine
-    console.log("Creating proving keys from local key files");
-    const feePublicKeyBytes = await getLocalKey(keyPaths[CREDITS_PROGRAM_KEYS.fee_public.locator]);
-    const feePublicProvingKey = ProvingKey.fromBytes(feePublicKeyBytes);
-    const transferPublicProvingKey = ProvingKey.fromBytes(await getLocalKey(keyPaths[CREDITS_PROGRAM_KEYS.transfer_public.locator]));
-    // Create an offline key provider
-    console.log("Creating offline key provider");
-    const offlineKeyProvider = new OfflineKeyProvider();
-    // Insert the proving keys into the offline key provider. The key provider will automatically insert the verifying
-    // keys into the key manager.
-    console.log("Inserting proving keys into key provider");
-    offlineKeyProvider.insertFeePublicKeys(feePublicProvingKey);
-    try {
-        offlineKeyProvider.insertTransferPublicKeys(transferPublicProvingKey);
-        console.log("Successfully inserted proving key");
-    }
-    catch (err) {
-        console.error("Failed to insert proving key:", err);
-    }
-    // Create an offline query to complete the inclusion proof
-    let offlineQuery;
-    const blockHeight = 0;
-    // TODO this is a placeholder block height for now, which offlineQuery now requires
-    try {
-        const offlineQuery = new OfflineQuery(blockHeight, latestStateRoot);
-        console.log("Successfully created OfflineQuery", offlineQuery);
-    }
-    catch (err) {
-        console.error("Failed to create OfflineQuery:", err);
-    }
-    // Insert the key provider into the program manager
-    programManager.setKeyProvider(offlineKeyProvider);
-    // Build tne transfer_public transaction offline
-    console.log("Building transfer transaction offline");
-    return programManager.buildTransferPublicAsSignerTransaction(amount, recipientAddress.to_string(), 0.28, undefined, offlineQuery);
-}
-/// Build bonding and unbonding transactions without connection to the internet
-async function buildBondingTxOffline(validatorAddress, withdrawalAddress, amount, latestStateRoot, keyPaths) {
-    // Create an offline program manager
-    const programManager = new ProgramManager();
-    // Create a temporary account for the execution of the program
-    const account = new Account();
-    programManager.setAccount(account);
-    // Create the proving keys from the key bytes on the offline machine
-    console.log("Creating proving keys from local key files");
-    const feePublicKeyBytes = await getLocalKey(keyPaths[CREDITS_PROGRAM_KEYS.fee_public.locator]);
-    const bondPublicKeyBytes = await getLocalKey(keyPaths[CREDITS_PROGRAM_KEYS.bond_public.locator]);
-    const unbondPublicKeyBytes = await getLocalKey(keyPaths[CREDITS_PROGRAM_KEYS.unbond_public.locator]);
-    const claimUnbondPublicKeyBytes = await getLocalKey(keyPaths[CREDITS_PROGRAM_KEYS.claim_unbond_public.locator]);
-    const feePublicProvingKey = ProvingKey.fromBytes(feePublicKeyBytes);
-    const bondPublicProvingKey = ProvingKey.fromBytes(bondPublicKeyBytes);
-    const unBondPublicProvingKey = ProvingKey.fromBytes(unbondPublicKeyBytes);
-    const claimUnbondPublicProvingKey = ProvingKey.fromBytes(claimUnbondPublicKeyBytes);
-    // Create an offline key provider to fetch keys without connection to the internet
-    console.log("Creating offline key provider");
-    const offlineKeyProvider = new OfflineKeyProvider();
-    // Insert the proving keys into the offline key provider
-    console.log("Inserting proving keys into key provider");
-    offlineKeyProvider.insertFeePublicKeys(feePublicProvingKey);
-    offlineKeyProvider.insertBondPublicKeys(bondPublicProvingKey);
-    offlineKeyProvider.insertUnbondPublicKeys(unBondPublicProvingKey);
-    offlineKeyProvider.insertClaimUnbondPublicKeys(claimUnbondPublicProvingKey);
-    // Insert the key provider into the program manager
-    programManager.setKeyProvider(offlineKeyProvider);
-    // Build the bonding transactions offline
-    console.log("Building a bond_public execution transaction offline");
-    const bondPublicOptions = {
-        keySearchParams: OfflineSearchParams.bondPublicKeyParams(),
-        offlineQuery: new OfflineQuery(0, latestStateRoot)
-    };
-    const bondTx = await programManager.buildBondPublicTransaction(validatorAddress.to_string(), withdrawalAddress.to_string(), amount, bondPublicOptions);
-    console.log("\nbond_public transaction built!\n");
-    const unbondPublicOptions = {
-        keySearchParams: OfflineSearchParams.unbondPublicKeyParams(),
-        offlineQuery: new OfflineQuery(0, latestStateRoot)
-    };
-    const unBondTx = await programManager.buildUnbondPublicTransaction(stakerAddress.to_string(), amount, unbondPublicOptions);
-    console.log("\nunbond_public transaction built!\n");
-    console.log("Building a claim_unbond_public transaction offline");
-    const claimUnbondPublicOptions = {
-        keySearchParams: OfflineSearchParams.claimUnbondPublicKeyParams(),
-        offlineQuery: new OfflineQuery(0, latestStateRoot)
-    };
-    const claimUnbondTx = await programManager.buildClaimUnbondPublicTransaction(stakerAddress.to_string(), claimUnbondPublicOptions);
-    console.log("\nclaim_unbond_public transaction built!\n");
-    return [bondTx, unBondTx, claimUnbondTx];
-}
-// -------------------ONLINE COMPONENT---------------------
-//     (Do this part on an internet connected machine)
-// Download the needed keys for the functions we want to execute offline
-const transferKeyPaths = await preDownloadTransferKeys();
-const bondingKeyPaths = await preDownloadBondingKeys();
-//---------------------------------------------------------
-// ------------------OFFLINE COMPONENT---------------------
-//           (Do this part on an offline machine)
-// Get the latest state root from an online machine and enter it into an offline machine
-const latestStateRoot = "sr1p93gpsezrjzdhcd2wujznx5s07k8qa39t6vfcej35zew8vn2jyrs46te8q";
-// Build a transfer_public transaction
-const stakerAddress = new Account().address();
-const validatorAddress = new Account().address();
-const withdrawalAddress = new Account().address();
-const transferTx = await buildTransferPublicTxOffline(stakerAddress, 10000, latestStateRoot, transferKeyPaths);
-console.log("Transfer transaction built offline!");
-console.log(`\n---------------transfer_public transaction---------------\n${transferTx}`);
-console.log(`---------------------------------------------------------`);
-// Build bonding & unbonding transactions
-const bondTransactions = await buildBondingTxOffline(validatorAddress, withdrawalAddress, 100, latestStateRoot, bondingKeyPaths);
-console.log("Bonding transactions built offline!");
-console.log(`\n-----------------bond_public transaction-----------------\n${bondTransactions[0]}`);
-console.log(`---------------------------------------------------------`);
-console.log(`\n----------------unbond_public transaction:---------------\n${bondTransactions[1]}`);
-console.log(`---------------------------------------------------------`);
-console.log(`\n-----------------claim_unbond_public transaction:---------------\n${bondTransactions[2]}`);
-console.log(`---------------------------------------------------------`);
-//---------------------------------------------------------
-// -------------------ONLINE COMPONENT---------------------
-//     (Do this part on an internet connected machine)
-// ONLINE COMPONENT (Uncomment this part to send the transaction to the Aleo Network on an internet connected machine)
-// Submit the transaction to the network
-// const transferTxId = await networkClient.submitTransaction(transferTx);
-//---------------------------------------------------------
-//# sourceMappingURL=index.js.map

package/template-offline-public-transaction-ts/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}