hyli-noir 0.0.2 → 0.1.0

package/README.md

@@ -1,35 +1,172 @@
-# Check Secret Noir
+# Hyli-noir
 
-This is a demonstration project that shows how to implement a secret checking system using Noir (a Domain Specific Language for SNARK proving systems) with a web frontend.
+A TypeScript/JavaScript library providing Noir-based zero-knowledge proof functionality for the Hyli ecosystem. This library enables secure secret verification through cryptographic proofs without revealing sensitive information.
 
-## Project Structure
+## Features
 
-- `/contract` - Contains the Noir smart contract code
-  - `src/main.nr` - The main Noir contract implementing the secret checking logic
-- `/frontend` - Web interface implementation
+- 🔐 **Zero-Knowledge Secret Verification**: Generate proofs that demonstrate knowledge of a password without revealing it
+- 🛡️ **Identity-Based Authentication**: Combine user identity with password hashing for secure authentication
+- 📦 **Blob Transaction Support**: Create and manage blob transactions containing encrypted secrets
+- ⚡ **Noir Circuit Integration**: Built on Noir's zero-knowledge proof system with UltraHonk backend
+- 🔧 **TypeScript Support**: Full TypeScript definitions and type safety
 
-## Features
+## Installation
+
+```bash
+npm install hyli-noir
+```
+
+### Peer Dependencies
+
+This library requires the following peer dependencies:
+
+```bash
+npm install @aztec/bb.js@0.82.2 @noir-lang/noir_js@1.0.0-beta.2 @noir-lang/noir_wasm@1.0.0-beta.2
+```
+
+## Quick Start
+
+```typescript
+import { check_secret } from 'hyli-noir';
+
+// Hash a password
+const hashedPassword = await check_secret.hash_password('my-secret-password');
+
+// Generate identity hash
+const identityHash = await check_secret.identity_hash('user@example.com', 'my-secret-password');
+
+// Build a blob transaction
+const blob = await check_secret.build_blob('user@example.com', 'my-secret-password');
+
+// Generate a proof transaction
+const proofTx = await check_secret.build_proof_transaction(
+  'user@example.com',
+  'my-secret-password',
+  '0x1234567890abcdef...', // transaction hash
+  0, // blob index
+  1  // total blob count
+);
+```
+
+## API Reference
+
+### Core Functions
+
+#### `hash_password(password: string): Promise<Uint8Array>`
+
+Hashes a password using SHA-256.
+
+**Parameters:**
+- `password` - The password string to hash
+
+**Returns:** Promise resolving to a 32-byte Uint8Array containing the SHA-256 hash
+
+#### `identity_hash(identity: string, password: string): Promise<string>`
+
+Creates a combined hash of identity and password for authentication.
+
+**Parameters:**
+- `identity` - The user's identity string
+- `password` - The user's password string
+
+**Returns:** Promise resolving to a hex-encoded string of the combined hash
+
+#### `build_blob(identity: string, password: string): Promise<Blob>`
+
+Creates a blob transaction containing a secret derived from identity and password.
 
-- Zero-knowledge proof based secret verification
-- Web interface for submitting identity and password
-- Real-time proof verification display
-- Secure password handling through zero-knowledge proofs, settling on Hyle network.
+**Parameters:**
+- `identity` - The user's identity string
+- `password` - The user's password string
 
-## Setup and Running
+**Returns:** Promise resolving to a Blob object containing the encrypted secret
+
+#### `build_proof_transaction(identity, password, tx_hash, blob_index, tx_blob_count, circuit?): Promise<ProofTransaction>`
+
+Generates a zero-knowledge proof transaction demonstrating knowledge of the password.
+
+**Parameters:**
+- `identity` - The user's identity string
+- `password` - The user's password string
+- `tx_hash` - The blob transaction hash string
+- `blob_index` - The index of the blob in the transaction
+- `tx_blob_count` - Total number of blobs in the transaction
+- `circuit` - Optional compiled Noir circuit (defaults to check_secret circuit)
+
+**Returns:** Promise resolving to a ProofTransaction containing the generated proof
+
+#### `register_contract(node, circuit?): Promise<void>`
+
+Registers the Noir contract with the node if not already registered.
+
+**Parameters:**
+- `node` - The NodeApiHttpClient instance
+- `circuit` - Optional compiled Noir circuit (defaults to check_secret circuit)
+
+### Utility Functions
+
+#### `assert(condition: boolean, message: string): void`
+
+Throws an error if the condition is false.
+
+#### `sha256(data: Uint8Array): Promise<Uint8Array>`
+
+Computes SHA-256 hash of the input data.
+
+#### `stringToBytes(input: string): Uint8Array`
+
+Converts a string to Uint8Array using UTF-8 encoding.
+
+#### `encodeToHex(data: Uint8Array): string`
+
+Converts Uint8Array to hex string representation.
+
+## How It Works
+
+The library implements a zero-knowledge proof system for secret verification:
+
+1. **Password Hashing**: The user's password is hashed using SHA-256 to create a fixed-size secret
+2. **Identity Combination**: The identity is concatenated with the hashed password using a colon separator
+3. **Final Hash**: The combined value is hashed again to create the stored secret
+4. **Proof Generation**: A zero-knowledge proof is generated that demonstrates knowledge of the password without revealing it
+5. **Verification**: The proof can be verified against the stored hash without exposing the original password
+
+## Security Considerations
+
+- Passwords are never stored in plain text
+- The zero-knowledge proof system ensures password privacy
+- All cryptographic operations use industry-standard algorithms (SHA-256)
+- The system is designed to prevent replay attacks and unauthorized access
+
+## Development
+
+### Building
 
-1. Install dependencies:
 ```bash
-# In the frontend directory
-bun install
+bun run build
 ```
 
-2. Run the frontend development server:
+### Publishing
+
 ```bash
-# In the frontend directory
-bun run dev
+bun run pub
 ```
 
-## Security
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Support
+
+For issues and questions:
+- GitHub Issues: [https://github.com/hyli-org/hyli-noir/issues](https://github.com/hyli-org/hyli-noir/issues)
+- Repository: [https://github.com/hyli-org/hyli-noir](https://github.com/hyli-org/hyli-noir)
 
-This example demonstrates zero-knowledge proof concepts for password verification. The password is never directly exposed in the verification process, enhancing security through cryptographic proofs.
+## Related Projects
 
+- [Hyli](https://github.com/hyli-org/hyli) - The main Hyli ecosystem
+- [Noir](https://noir-lang.org/) - Zero-knowledge proof language

package/dist/check_secret.d.ts

@@ -1,6 +1,27 @@
 import { CompiledCircuit } from "@noir-lang/types";
 import { Blob, ProofTransaction, NodeApiHttpClient } from "hyli";
+/**
+ * Hashes a password using SHA-256.
+ * The password is converted to a Uint8Array and hashed using SHA-256.
+ * The resulting hash is returned as a Uint8Array.
+ *
+ * @param password - The password string to hash
+ * @returns A Promise resolving to the Uint8Array of the computed hash
+ */
 export declare const hash_password: (password: string) => Promise<Uint8Array>;
+/**
+ * Hashes an identity and password together using SHA-256.
+ * The identity is concatenated with ':' and the hashed password.
+ * The resulting combined value is hashed again using SHA-256.
+ * The resulting hash is returned as a hexadecimal string that can be
+ * stored publicly.
+ *
+ * This function is mainly used to check the given password against a stored hash.
+ *
+ * @param identity - The user's identity string
+ * @param password - The user's password string
+ * @returns A Promise resolving to the hexadecimal string of the computed hash
+ */
 export declare const identity_hash: (identity: string, password: string) => Promise<string>;
 /**
  * Builds a blob transaction containing a secret derived from an identity and password.

package/dist/hyli-noir.cjs.js.map

@@ -1 +1 @@
-{"version":3,"file":"hyli-noir.cjs.js","sources":["../node_modules/@noir-lang/noir_js/lib/base64_decode.mjs","../node_modules/@noir-lang/noir_js/lib/witness_generation.mjs","../node_modules/@noir-lang/noir_js/lib/program.mjs","../src/check_secret.ts"],"sourcesContent":["// Since this is a simple function, we can use feature detection to\n// see if we are in the nodeJs environment or the browser environment.\nexport function base64Decode(input) {\n    if (typeof Buffer !== 'undefined') {\n        // Node.js environment\n        return Buffer.from(input, 'base64');\n    }\n    else if (typeof atob === 'function') {\n        // Browser environment\n        return Uint8Array.from(atob(input), (c) => c.charCodeAt(0));\n    }\n    else {\n        throw new Error('No implementation found for base64 decoding.');\n    }\n}\n","import { abiDecodeError, abiEncode } from '@noir-lang/noirc_abi';\nimport { base64Decode } from \"./base64_decode.mjs\";\nimport { executeProgram } from '@noir-lang/acvm_js';\nconst defaultForeignCallHandler = async (name, args) => {\n    if (name == 'print') {\n        // By default we do not print anything for `print` foreign calls due to a need for formatting,\n        // however we provide an empty response in order to not halt execution.\n        //\n        // If a user needs to print values then they should provide a custom foreign call handler.\n        return [];\n    }\n    throw Error(`Unexpected oracle during execution: ${name}(${args.join(', ')})`);\n};\nfunction parseErrorPayload(abi, originalError) {\n    const payload = originalError.rawAssertionPayload;\n    if (!payload)\n        return originalError;\n    const enrichedError = originalError;\n    try {\n        // Decode the payload\n        const decodedPayload = abiDecodeError(abi, payload);\n        if (typeof decodedPayload === 'string') {\n            // If it's a string, just add it to the error message\n            enrichedError.message = `Circuit execution failed: ${decodedPayload}`;\n        }\n        else {\n            // If not, attach the payload to the original error\n            enrichedError.decodedAssertionPayload = decodedPayload;\n        }\n    }\n    catch (_errorDecoding) {\n        // Ignore errors decoding the payload\n    }\n    return enrichedError;\n}\n// Generates the witnesses needed to feed into the chosen proving system\nexport async function generateWitness(compiledProgram, inputs, foreignCallHandler = defaultForeignCallHandler) {\n    // Throws on ABI encoding error\n    const witnessMap = abiEncode(compiledProgram.abi, inputs);\n    // Execute the circuit to generate the rest of the witnesses and serialize\n    // them into a Uint8Array.\n    try {\n        const solvedWitness = await executeProgram(base64Decode(compiledProgram.bytecode), witnessMap, foreignCallHandler);\n        return solvedWitness;\n    }\n    catch (err) {\n        // Typescript types catched errors as unknown or any, so we need to narrow its type to check if it has raw assertion payload.\n        if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {\n            throw parseErrorPayload(compiledProgram.abi, err);\n        }\n        throw new Error(`Circuit execution failed: ${err}`);\n    }\n}\n","import { generateWitness } from \"./witness_generation.mjs\";\nimport initAbi, { abiDecode } from '@noir-lang/noirc_abi';\nimport initACVM, { compressWitnessStack } from '@noir-lang/acvm_js';\nexport class Noir {\n    circuit;\n    constructor(circuit) {\n        this.circuit = circuit;\n    }\n    /** @ignore */\n    async init() {\n        // If these are available, then we are in the\n        // web environment. For the node environment, this\n        // is a no-op.\n        if (typeof initAbi === 'function') {\n            await Promise.all([initAbi(), initACVM()]);\n        }\n    }\n    /**\n     * @description\n     * Allows to execute a circuit to get its witness and return value.\n     *\n     * @example\n     * ```typescript\n     * async execute(inputs)\n     * ```\n     */\n    async execute(inputs, foreignCallHandler) {\n        await this.init();\n        const witness_stack = await generateWitness(this.circuit, inputs, foreignCallHandler);\n        const main_witness = witness_stack[0].witness;\n        const { return_value: returnValue } = abiDecode(this.circuit.abi, main_witness);\n        return { witness: compressWitnessStack(witness_stack), returnValue };\n    }\n}\n","import { Noir } from \"@noir-lang/noir_js\";\nimport { reconstructHonkProof, UltraHonkBackend } from \"@aztec/bb.js\";\nimport { CompiledCircuit, InputMap } from \"@noir-lang/types\";\nimport { Blob, ProofTransaction, NodeApiHttpClient } from \"hyli\";\n\nexport const hash_password = async (password: string): Promise<Uint8Array> => {\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  return hashed_password_bytes;\n};\n\nexport const identity_hash = async (identity: string, password: string): Promise<string> => {\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  let encoder = new TextEncoder();\n  let id_prefix = encoder.encode(`${identity}:`);\n  let extended_id = new Uint8Array([...id_prefix, ...hashed_password_bytes]);\n  const computed_hash = await sha256(extended_id);\n  const computed_hash_hex = Buffer.from(computed_hash).toString(\"hex\");\n  return computed_hash_hex;\n};\n\n/**\n * Builds a blob transaction containing a secret derived from an identity and password.\n * The secret is constructed by:\n * 1. Hashing the password in order to have a fixed-size secret\n * 2. Concatenating the padded identity (to 64 chars) with ':' and the hashed password\n * 3. Hashing this combined value\n *\n * @param identity - The user's identity string\n * @param password - The user's password string\n * @returns A Promise resolving to a BlobTransaction containing the hashed secret\n */\nexport const build_blob = async (identity: string, password: string): Promise<Blob> => {\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  let encoder = new TextEncoder();\n  let id_prefix = encoder.encode(`${identity}:`);\n  let extended_id = new Uint8Array([...id_prefix, ...hashed_password_bytes]);\n  const stored_hash = await sha256(extended_id);\n\n  const secretBlob: Blob = {\n    contract_name: \"check_secret\",\n    data: Array.from(stored_hash),\n  };\n\n  return secretBlob;\n};\n\nimport defaultCircuit from \"../check-secret/target/check_secret.json\";\n\n/**\n * Builds a proof transaction by generating a zero-knowledge proof for checking a secret.\n * The proof demonstrates knowledge of a password that, when combined with an identity and hashed,\n * matches a stored hash value. The process involves:\n * 1. Hashing the password and combining it with the identity\n * 2. Generating a witness and proof using the UltraHonk backend\n * 3. Reconstructing and formatting the proof for the transaction\n *\n * @param identity - The user's identity string\n * @param password - The user's password string\n * @param tx_hash - The blob transaction hash string\n * @param circuit - The compiled Noir circuit (defaults to the check_secret circuit)\n * @returns A Promise resolving to a ProofTransaction containing the generated proof\n */\nexport const build_proof_transaction = async (\n  identity: string,\n  password: string,\n  tx_hash: string,\n  blob_index: number,\n  tx_blob_count: number,\n  circuit: CompiledCircuit = defaultCircuit as CompiledCircuit,\n): Promise<ProofTransaction> => {\n  const noir = new Noir(circuit);\n  const backend = new UltraHonkBackend(circuit.bytecode);\n  const vk = await backend.getVerificationKey();\n\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  let encoder = new TextEncoder();\n  let id_prefix = encoder.encode(`${identity}:`);\n  let extended_id = new Uint8Array([...id_prefix, ...hashed_password_bytes]);\n  const stored_hash = await sha256(extended_id);\n\n  const { witness } = await noir.execute(\n    generateProverData(identity, hashed_password_bytes, stored_hash, tx_hash, blob_index, tx_blob_count),\n  );\n\n  const proof = await backend.generateProof(witness);\n  const reconstructedProof = reconstructHonkProof(flattenFieldsAsArray(proof.publicInputs), proof.proof);\n\n  return {\n    contract_name: \"check_secret\",\n    program_id: Array.from(vk),\n    verifier: \"noir\",\n    proof: Array.from(reconstructedProof),\n  };\n};\n\n/**\n * Registers the Noir contract with the node if it is not already registered.\n * The contract is identified by its name \"check_secret\".\n * If the contract is not found, it registers the contract using the provided circuit.\n *\n * @param node - The NodeApiHttpClient instance to interact with the NodeApiHttpClient\n * @param circuit - The compiled Noir circuit (defaults to the check_secret circuit)\n * @returns A Promise that resolves when the contract is registered\n */\nexport const register_contract = async (\n  node: NodeApiHttpClient,\n  circuit: CompiledCircuit = defaultCircuit as CompiledCircuit,\n): Promise<void> => {\n  await node.getContract(\"check_secret\").catch(async () => {\n    const backend = new UltraHonkBackend(circuit.bytecode);\n\n    const vk = await backend.getVerificationKey();\n\n    await node.registerContract({\n      verifier: \"noir\",\n      program_id: Array.from(vk),\n      state_commitment: [0, 0, 0, 0],\n      contract_name: \"check_secret\",\n    });\n  });\n};\n\n// ---- Utility functions ----\n\nexport const assert = (condition: boolean, message: string): void => {\n  if (!condition) {\n    throw new Error(message);\n  }\n};\n\nexport const sha256 = async (data: Uint8Array): Promise<Uint8Array> => {\n  const hashBuffer = await crypto.subtle.digest(\"SHA-256\", data);\n  return new Uint8Array(hashBuffer);\n};\n\nexport const stringToBytes = (input: string): Uint8Array => {\n  return new TextEncoder().encode(input);\n};\n\nexport const encodeToHex = (data: Uint8Array): string => {\n  return Array.from(data)\n    .map((byte) => byte.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n};\n\nexport function flattenFieldsAsArray(fields: string[]): Uint8Array {\n  const flattenedPublicInputs = fields.map(hexToUint8Array);\n  return flattenUint8Arrays(flattenedPublicInputs);\n}\n\nfunction flattenUint8Arrays(arrays: Uint8Array[]): Uint8Array {\n  const totalLength = arrays.reduce((acc, val) => acc + val.length, 0);\n  const result = new Uint8Array(totalLength);\n\n  let offset = 0;\n  for (const arr of arrays) {\n    result.set(arr, offset);\n    offset += arr.length;\n  }\n\n  return result;\n}\n\nfunction hexToUint8Array(hex: string): Uint8Array {\n  const sanitisedHex = BigInt(hex).toString(16).padStart(64, \"0\");\n\n  const len = sanitisedHex.length / 2;\n  const u8 = new Uint8Array(len);\n\n  let i = 0;\n  let j = 0;\n  while (i < len) {\n    u8[i] = parseInt(sanitisedHex.slice(j, j + 2), 16);\n    i += 1;\n    j += 2;\n  }\n\n  return u8;\n}\n\n/**\n * Generates the prover data required for the Noir circuit.\n *\n * @param id - The user's identity string\n * @param pwd - The hashed password as a Uint8Array\n * @param stored_hash - The stored hash as a Uint8Array\n * @param tx - The transaction hash string\n * @returns An object containing the prover data\n */\nconst generateProverData = (\n  id: string,\n  pwd: Uint8Array,\n  stored_hash: Uint8Array,\n  tx: string,\n  blob_index: number,\n  tx_blob_count: number,\n): InputMap => {\n  const version = 1;\n  const initial_state = [0, 0, 0, 0];\n  const initial_state_len = initial_state.length;\n  const next_state = [0, 0, 0, 0];\n  const next_state_len = next_state.length;\n  const identity_len = id.length;\n  const identity = id.padEnd(256, \"0\");\n  const tx_hash = tx.padEnd(64, \"0\");\n  const tx_hash_len = tx_hash.length;\n  const index = blob_index;\n  const blob_number = 1;\n  const blob_contract_name_len = \"check_secret\".length;\n  const blob_contract_name = \"check_secret\".padEnd(256, \"0\");\n  const blob_capacity = 32;\n  const blob_len = 32;\n  const blob: number[] = Array.from(stored_hash);\n  const success = 1;\n  const password: number[] = Array.from(pwd);\n  assert(password.length == 32, \"Password length is not 32 bytes\");\n  assert(blob.length == blob_len, \"Blob length is not 32 bytes\");\n\n  return {\n    version,\n    initial_state,\n    initial_state_len,\n    next_state,\n    next_state_len,\n    identity,\n    identity_len,\n    tx_hash,\n    tx_hash_len,\n    index,\n    blob_number,\n    blob_index,\n    blob_contract_name_len,\n    blob_contract_name,\n    blob_capacity,\n    blob_len,\n    blob,\n    tx_blob_count,\n    success,\n    password,\n  };\n};\n"],"names":["base64Decode","input","c","defaultForeignCallHandler","name","args","parseErrorPayload","abi","originalError","payload","enrichedError","decodedPayload","abiDecodeError","generateWitness","compiledProgram","inputs","foreignCallHandler","witnessMap","abiEncode","executeProgram","err","Noir","circuit","__publicField","initAbi","initACVM","witness_stack","main_witness","returnValue","abiDecode","compressWitnessStack","hash_password","password","sha256","stringToBytes","identity_hash","identity","hashed_password_bytes","id_prefix","extended_id","computed_hash","build_blob","stored_hash","build_proof_transaction","tx_hash","blob_index","tx_blob_count","defaultCircuit","noir","backend","UltraHonkBackend","vk","witness","generateProverData","proof","reconstructedProof","reconstructHonkProof","flattenFieldsAsArray","register_contract","node","assert","condition","message","data","hashBuffer","encodeToHex","byte","fields","flattenedPublicInputs","hexToUint8Array","flattenUint8Arrays","arrays","totalLength","acc","val","result","offset","arr","hex","sanitisedHex","len","u8","i","j","id","pwd","tx","initial_state","initial_state_len","next_state","next_state_len","identity_len","tx_hash_len","index","blob_number","blob_contract_name_len","blob_contract_name","blob_capacity","blob_len","blob","success"],"mappings":"sVAEO,SAASA,EAAaC,EAAO,CAChC,GAAI,OAAO,OAAW,IAElB,OAAO,OAAO,KAAKA,EAAO,QAAQ,EAEjC,GAAI,OAAO,MAAS,WAErB,OAAO,WAAW,KAAK,KAAKA,CAAK,EAAIC,GAAMA,EAAE,WAAW,CAAC,CAAC,EAG1D,MAAM,IAAI,MAAM,8CAA8C,CAEtE,CCXA,MAAMC,EAA4B,MAAOC,EAAMC,IAAS,CACpD,GAAID,GAAQ,QAKR,MAAO,CAAE,EAEb,MAAM,MAAM,uCAAuCA,CAAI,IAAIC,EAAK,KAAK,IAAI,CAAC,GAAG,CACjF,EACA,SAASC,EAAkBC,EAAKC,EAAe,CAC3C,MAAMC,EAAUD,EAAc,oBAC9B,GAAI,CAACC,EACD,OAAOD,EACX,MAAME,EAAgBF,EACtB,GAAI,CAEA,MAAMG,EAAiBC,EAAAA,eAAeL,EAAKE,CAAO,EAC9C,OAAOE,GAAmB,SAE1BD,EAAc,QAAU,6BAA6BC,CAAc,GAInED,EAAc,wBAA0BC,CAEpD,MAC2B,CAE3B,CACI,OAAOD,CACX,CAEO,eAAeG,EAAgBC,EAAiBC,EAAQC,EAAqBb,EAA2B,CAE3G,MAAMc,EAAaC,EAAS,UAACJ,EAAgB,IAAKC,CAAM,EAGxD,GAAI,CAEA,OADsB,MAAMI,EAAAA,eAAenB,EAAac,EAAgB,QAAQ,EAAGG,EAAYD,CAAkB,CAEzH,OACWI,EAAK,CAER,MAAI,OAAOA,GAAQ,UAAYA,IAAQ,MAAQ,wBAAyBA,EAC9Dd,EAAkBQ,EAAgB,IAAKM,CAAG,EAE9C,IAAI,MAAM,6BAA6BA,CAAG,EAAE,CAC1D,CACA,CCjDO,MAAMC,CAAK,CAEd,YAAYC,EAAS,CADrBC,EAAA,gBAEI,KAAK,QAAUD,CACvB,CAEI,MAAM,MAAO,CAIL,OAAOE,GAAY,YACnB,MAAM,QAAQ,IAAI,CAACA,EAAO,EAAIC,EAAU,CAAA,CAAC,CAErD,CAUI,MAAM,QAAQV,EAAQC,EAAoB,CACtC,MAAM,KAAK,KAAM,EACjB,MAAMU,EAAgB,MAAMb,EAAgB,KAAK,QAASE,EAAQC,CAAkB,EAC9EW,EAAeD,EAAc,CAAC,EAAE,QAChC,CAAE,aAAcE,GAAgBC,EAAAA,UAAU,KAAK,QAAQ,IAAKF,CAAY,EAC9E,MAAO,CAAE,QAASG,EAAAA,qBAAqBJ,CAAa,EAAG,YAAAE,CAAa,CAC5E,CACA,ijrPC5BaG,EAAgB,MAAOC,GACJ,MAAMC,EAAOC,EAAcF,CAAQ,CAAC,EAIvDG,EAAgB,MAAOC,EAAkBJ,IAAsC,CAC1F,MAAMK,EAAwB,MAAMJ,EAAOC,EAAcF,CAAQ,CAAC,EAElE,IAAIM,EADU,IAAI,YAAY,EACN,OAAO,GAAGF,CAAQ,GAAG,EACzCG,EAAc,IAAI,WAAW,CAAC,GAAGD,EAAW,GAAGD,CAAqB,CAAC,EACnE,MAAAG,EAAgB,MAAMP,EAAOM,CAAW,EAEvC,OADmB,OAAO,KAAKC,CAAa,EAAE,SAAS,KAAK,CAErE,EAaaC,EAAa,MAAOL,EAAkBJ,IAAoC,CACrF,MAAMK,EAAwB,MAAMJ,EAAOC,EAAcF,CAAQ,CAAC,EAElE,IAAIM,EADU,IAAI,YAAY,EACN,OAAO,GAAGF,CAAQ,GAAG,EACzCG,EAAc,IAAI,WAAW,CAAC,GAAGD,EAAW,GAAGD,CAAqB,CAAC,EACnE,MAAAK,EAAc,MAAMT,EAAOM,CAAW,EAOrC,MALkB,CACvB,cAAe,eACf,KAAM,MAAM,KAAKG,CAAW,CAC9B,CAGF,EAkBaC,EAA0B,MACrCP,EACAJ,EACAY,EACAC,EACAC,EACAxB,EAA2ByB,IACG,CACxB,MAAAC,EAAO,IAAI3B,EAAKC,CAAO,EACvB2B,EAAU,IAAIC,mBAAiB5B,EAAQ,QAAQ,EAC/C6B,EAAK,MAAMF,EAAQ,mBAAmB,EAEtCZ,EAAwB,MAAMJ,EAAOC,EAAcF,CAAQ,CAAC,EAElE,IAAIM,EADU,IAAI,YAAY,EACN,OAAO,GAAGF,CAAQ,GAAG,EACzCG,EAAc,IAAI,WAAW,CAAC,GAAGD,EAAW,GAAGD,CAAqB,CAAC,EACnE,MAAAK,EAAc,MAAMT,EAAOM,CAAW,EAEtC,CAAE,QAAAa,CAAA,EAAY,MAAMJ,EAAK,QAC7BK,GAAmBjB,EAAUC,EAAuBK,EAAaE,EAASC,EAAYC,CAAa,CACrG,EAEMQ,EAAQ,MAAML,EAAQ,cAAcG,CAAO,EAC3CG,EAAqBC,EAAAA,qBAAqBC,EAAqBH,EAAM,YAAY,EAAGA,EAAM,KAAK,EAE9F,MAAA,CACL,cAAe,eACf,WAAY,MAAM,KAAKH,CAAE,EACzB,SAAU,OACV,MAAO,MAAM,KAAKI,CAAkB,CACtC,CACF,EAWaG,EAAoB,MAC/BC,EACArC,EAA2ByB,IACT,CAClB,MAAMY,EAAK,YAAY,cAAc,EAAE,MAAM,SAAY,CAGjD,MAAAR,EAAK,MAFK,IAAID,mBAAiB5B,EAAQ,QAAQ,EAE5B,mBAAmB,EAE5C,MAAMqC,EAAK,iBAAiB,CAC1B,SAAU,OACV,WAAY,MAAM,KAAKR,CAAE,EACzB,iBAAkB,CAAC,EAAG,EAAG,EAAG,CAAC,EAC7B,cAAe,cAAA,CAChB,CAAA,CACF,CACH,EAIaS,EAAS,CAACC,EAAoBC,IAA0B,CACnE,GAAI,CAACD,EACG,MAAA,IAAI,MAAMC,CAAO,CAE3B,EAEa7B,EAAS,MAAO8B,GAA0C,CACrE,MAAMC,EAAa,MAAM,OAAO,OAAO,OAAO,UAAWD,CAAI,EACtD,OAAA,IAAI,WAAWC,CAAU,CAClC,EAEa9B,EAAiBjC,GACrB,IAAI,YAAA,EAAc,OAAOA,CAAK,EAG1BgE,EAAeF,GACnB,MAAM,KAAKA,CAAI,EACnB,IAAKG,GAASA,EAAK,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,CAAC,EAChD,KAAK,EAAE,EAGL,SAAST,EAAqBU,EAA8B,CAC3D,MAAAC,EAAwBD,EAAO,IAAIE,EAAe,EACxD,OAAOC,GAAmBF,CAAqB,CACjD,CAEA,SAASE,GAAmBC,EAAkC,CACtD,MAAAC,EAAcD,EAAO,OAAO,CAACE,EAAKC,IAAQD,EAAMC,EAAI,OAAQ,CAAC,EAC7DC,EAAS,IAAI,WAAWH,CAAW,EAEzC,IAAII,EAAS,EACb,UAAWC,KAAON,EACTI,EAAA,IAAIE,EAAKD,CAAM,EACtBA,GAAUC,EAAI,OAGT,OAAAF,CACT,CAEA,SAASN,GAAgBS,EAAyB,CAC1C,MAAAC,EAAe,OAAOD,CAAG,EAAE,SAAS,EAAE,EAAE,SAAS,GAAI,GAAG,EAExDE,EAAMD,EAAa,OAAS,EAC5BE,EAAK,IAAI,WAAWD,CAAG,EAE7B,IAAIE,EAAI,EACJC,EAAI,EACR,KAAOD,EAAIF,GACNC,EAAAC,CAAC,EAAI,SAASH,EAAa,MAAMI,EAAGA,EAAI,CAAC,EAAG,EAAE,EAC5CD,GAAA,EACAC,GAAA,EAGA,OAAAF,CACT,CAWA,MAAM5B,GAAqB,CACzB+B,EACAC,EACA3C,EACA4C,EACAzC,EACAC,IACa,CAEb,MAAMyC,EAAgB,CAAC,EAAG,EAAG,EAAG,CAAC,EAC3BC,EAAoBD,EAAc,OAClCE,EAAa,CAAC,EAAG,EAAG,EAAG,CAAC,EACxBC,EAAiBD,EAAW,OAC5BE,EAAeP,EAAG,OAClBhD,EAAWgD,EAAG,OAAO,IAAK,GAAG,EAC7BxC,EAAU0C,EAAG,OAAO,GAAI,GAAG,EAC3BM,EAAchD,EAAQ,OACtBiD,EAAQhD,EACRiD,EAAc,EACdC,EAAyB,GACzBC,EAAqB,eAAe,OAAO,IAAK,GAAG,EACnDC,EAAgB,GAChBC,EAAW,GACXC,EAAiB,MAAM,KAAKzD,CAAW,EACvC0D,EAAU,EACVpE,EAAqB,MAAM,KAAKqD,CAAG,EAClC,OAAAzB,EAAA5B,EAAS,QAAU,GAAI,iCAAiC,EACxD4B,EAAAuC,EAAK,QAAUD,EAAU,6BAA6B,EAEtD,CACL,UACA,cAAAX,EACA,kBAAAC,EACA,WAAAC,EACA,eAAAC,EACA,SAAAtD,EACA,aAAAuD,EACA,QAAA/C,EACA,YAAAgD,EACA,MAAAC,EACA,YAAAC,EACA,WAAAjD,EACA,uBAAAkD,EACA,mBAAAC,EACA,cAAAC,EACA,SAAAC,EACA,KAAAC,EACA,cAAArD,EACA,QAAAsD,EACA,SAAApE,CACF,CACF","x_google_ignoreList":[0,1,2]}
+{"version":3,"file":"hyli-noir.cjs.js","sources":["../node_modules/@noir-lang/noir_js/lib/base64_decode.mjs","../node_modules/@noir-lang/noir_js/lib/witness_generation.mjs","../node_modules/@noir-lang/noir_js/lib/program.mjs","../src/check_secret.ts"],"sourcesContent":["// Since this is a simple function, we can use feature detection to\n// see if we are in the nodeJs environment or the browser environment.\nexport function base64Decode(input) {\n    if (typeof Buffer !== 'undefined') {\n        // Node.js environment\n        return Buffer.from(input, 'base64');\n    }\n    else if (typeof atob === 'function') {\n        // Browser environment\n        return Uint8Array.from(atob(input), (c) => c.charCodeAt(0));\n    }\n    else {\n        throw new Error('No implementation found for base64 decoding.');\n    }\n}\n","import { abiDecodeError, abiEncode } from '@noir-lang/noirc_abi';\nimport { base64Decode } from \"./base64_decode.mjs\";\nimport { executeProgram } from '@noir-lang/acvm_js';\nconst defaultForeignCallHandler = async (name, args) => {\n    if (name == 'print') {\n        // By default we do not print anything for `print` foreign calls due to a need for formatting,\n        // however we provide an empty response in order to not halt execution.\n        //\n        // If a user needs to print values then they should provide a custom foreign call handler.\n        return [];\n    }\n    throw Error(`Unexpected oracle during execution: ${name}(${args.join(', ')})`);\n};\nfunction parseErrorPayload(abi, originalError) {\n    const payload = originalError.rawAssertionPayload;\n    if (!payload)\n        return originalError;\n    const enrichedError = originalError;\n    try {\n        // Decode the payload\n        const decodedPayload = abiDecodeError(abi, payload);\n        if (typeof decodedPayload === 'string') {\n            // If it's a string, just add it to the error message\n            enrichedError.message = `Circuit execution failed: ${decodedPayload}`;\n        }\n        else {\n            // If not, attach the payload to the original error\n            enrichedError.decodedAssertionPayload = decodedPayload;\n        }\n    }\n    catch (_errorDecoding) {\n        // Ignore errors decoding the payload\n    }\n    return enrichedError;\n}\n// Generates the witnesses needed to feed into the chosen proving system\nexport async function generateWitness(compiledProgram, inputs, foreignCallHandler = defaultForeignCallHandler) {\n    // Throws on ABI encoding error\n    const witnessMap = abiEncode(compiledProgram.abi, inputs);\n    // Execute the circuit to generate the rest of the witnesses and serialize\n    // them into a Uint8Array.\n    try {\n        const solvedWitness = await executeProgram(base64Decode(compiledProgram.bytecode), witnessMap, foreignCallHandler);\n        return solvedWitness;\n    }\n    catch (err) {\n        // Typescript types catched errors as unknown or any, so we need to narrow its type to check if it has raw assertion payload.\n        if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {\n            throw parseErrorPayload(compiledProgram.abi, err);\n        }\n        throw new Error(`Circuit execution failed: ${err}`);\n    }\n}\n","import { generateWitness } from \"./witness_generation.mjs\";\nimport initAbi, { abiDecode } from '@noir-lang/noirc_abi';\nimport initACVM, { compressWitnessStack } from '@noir-lang/acvm_js';\nexport class Noir {\n    circuit;\n    constructor(circuit) {\n        this.circuit = circuit;\n    }\n    /** @ignore */\n    async init() {\n        // If these are available, then we are in the\n        // web environment. For the node environment, this\n        // is a no-op.\n        if (typeof initAbi === 'function') {\n            await Promise.all([initAbi(), initACVM()]);\n        }\n    }\n    /**\n     * @description\n     * Allows to execute a circuit to get its witness and return value.\n     *\n     * @example\n     * ```typescript\n     * async execute(inputs)\n     * ```\n     */\n    async execute(inputs, foreignCallHandler) {\n        await this.init();\n        const witness_stack = await generateWitness(this.circuit, inputs, foreignCallHandler);\n        const main_witness = witness_stack[0].witness;\n        const { return_value: returnValue } = abiDecode(this.circuit.abi, main_witness);\n        return { witness: compressWitnessStack(witness_stack), returnValue };\n    }\n}\n","import { Noir } from \"@noir-lang/noir_js\";\nimport { reconstructHonkProof, UltraHonkBackend } from \"@aztec/bb.js\";\nimport { CompiledCircuit, InputMap } from \"@noir-lang/types\";\nimport { Blob, ProofTransaction, NodeApiHttpClient } from \"hyli\";\n\n/**\n * Hashes a password using SHA-256.\n * The password is converted to a Uint8Array and hashed using SHA-256.\n * The resulting hash is returned as a Uint8Array.\n *\n * @param password - The password string to hash\n * @returns A Promise resolving to the Uint8Array of the computed hash\n */\nexport const hash_password = async (password: string): Promise<Uint8Array> => {\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  return hashed_password_bytes;\n};\n\n/**\n * Hashes an identity and password together using SHA-256.\n * The identity is concatenated with ':' and the hashed password.\n * The resulting combined value is hashed again using SHA-256.\n * The resulting hash is returned as a hexadecimal string that can be \n * stored publicly.\n * \n * This function is mainly used to check the given password against a stored hash.\n *\n * @param identity - The user's identity string\n * @param password - The user's password string\n * @returns A Promise resolving to the hexadecimal string of the computed hash\n */\nexport const identity_hash = async (identity: string, password: string): Promise<string> => {\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  let encoder = new TextEncoder();\n  let id_prefix = encoder.encode(`${identity}:`);\n  let extended_id = new Uint8Array([...id_prefix, ...hashed_password_bytes]);\n  const computed_hash = await sha256(extended_id);\n  const computed_hash_hex = Buffer.from(computed_hash).toString(\"hex\");\n  return computed_hash_hex;\n};\n\n/**\n * Builds a blob transaction containing a secret derived from an identity and password.\n * The secret is constructed by:\n * 1. Hashing the password in order to have a fixed-size secret\n * 2. Concatenating the padded identity (to 64 chars) with ':' and the hashed password\n * 3. Hashing this combined value\n *\n * @param identity - The user's identity string\n * @param password - The user's password string\n * @returns A Promise resolving to a BlobTransaction containing the hashed secret\n */\nexport const build_blob = async (identity: string, password: string): Promise<Blob> => {\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  let encoder = new TextEncoder();\n  let id_prefix = encoder.encode(`${identity}:`);\n  let extended_id = new Uint8Array([...id_prefix, ...hashed_password_bytes]);\n  const stored_hash = await sha256(extended_id);\n\n  const secretBlob: Blob = {\n    contract_name: \"check_secret\",\n    data: Array.from(stored_hash),\n  };\n\n  return secretBlob;\n};\n\nimport defaultCircuit from \"../check-secret/target/check_secret.json\";\n\n/**\n * Builds a proof transaction by generating a zero-knowledge proof for checking a secret.\n * The proof demonstrates knowledge of a password that, when combined with an identity and hashed,\n * matches a stored hash value. The process involves:\n * 1. Hashing the password and combining it with the identity\n * 2. Generating a witness and proof using the UltraHonk backend\n * 3. Reconstructing and formatting the proof for the transaction\n *\n * @param identity - The user's identity string\n * @param password - The user's password string\n * @param tx_hash - The blob transaction hash string\n * @param circuit - The compiled Noir circuit (defaults to the check_secret circuit)\n * @returns A Promise resolving to a ProofTransaction containing the generated proof\n */\nexport const build_proof_transaction = async (\n  identity: string,\n  password: string,\n  tx_hash: string,\n  blob_index: number,\n  tx_blob_count: number,\n  circuit: CompiledCircuit = defaultCircuit as CompiledCircuit,\n): Promise<ProofTransaction> => {\n  const noir = new Noir(circuit);\n  const backend = new UltraHonkBackend(circuit.bytecode);\n  const vk = await backend.getVerificationKey();\n\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  let encoder = new TextEncoder();\n  let id_prefix = encoder.encode(`${identity}:`);\n  let extended_id = new Uint8Array([...id_prefix, ...hashed_password_bytes]);\n  const stored_hash = await sha256(extended_id);\n\n  const { witness } = await noir.execute(\n    generateProverData(identity, hashed_password_bytes, stored_hash, tx_hash, blob_index, tx_blob_count),\n  );\n\n  const proof = await backend.generateProof(witness);\n  const reconstructedProof = reconstructHonkProof(flattenFieldsAsArray(proof.publicInputs), proof.proof);\n\n  return {\n    contract_name: \"check_secret\",\n    program_id: Array.from(vk),\n    verifier: \"noir\",\n    proof: Array.from(reconstructedProof),\n  };\n};\n\n/**\n * Registers the Noir contract with the node if it is not already registered.\n * The contract is identified by its name \"check_secret\".\n * If the contract is not found, it registers the contract using the provided circuit.\n *\n * @param node - The NodeApiHttpClient instance to interact with the NodeApiHttpClient\n * @param circuit - The compiled Noir circuit (defaults to the check_secret circuit)\n * @returns A Promise that resolves when the contract is registered\n */\nexport const register_contract = async (\n  node: NodeApiHttpClient,\n  circuit: CompiledCircuit = defaultCircuit as CompiledCircuit,\n): Promise<void> => {\n  await node.getContract(\"check_secret\").catch(async () => {\n    const backend = new UltraHonkBackend(circuit.bytecode);\n\n    const vk = await backend.getVerificationKey();\n\n    await node.registerContract({\n      verifier: \"noir\",\n      program_id: Array.from(vk),\n      state_commitment: [0, 0, 0, 0],\n      contract_name: \"check_secret\",\n    });\n  });\n};\n\n// ---- Utility functions ----\n\nexport const assert = (condition: boolean, message: string): void => {\n  if (!condition) {\n    throw new Error(message);\n  }\n};\n\nexport const sha256 = async (data: Uint8Array): Promise<Uint8Array> => {\n  const hashBuffer = await crypto.subtle.digest(\"SHA-256\", data);\n  return new Uint8Array(hashBuffer);\n};\n\nexport const stringToBytes = (input: string): Uint8Array => {\n  return new TextEncoder().encode(input);\n};\n\nexport const encodeToHex = (data: Uint8Array): string => {\n  return Array.from(data)\n    .map((byte) => byte.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n};\n\nexport function flattenFieldsAsArray(fields: string[]): Uint8Array {\n  const flattenedPublicInputs = fields.map(hexToUint8Array);\n  return flattenUint8Arrays(flattenedPublicInputs);\n}\n\nfunction flattenUint8Arrays(arrays: Uint8Array[]): Uint8Array {\n  const totalLength = arrays.reduce((acc, val) => acc + val.length, 0);\n  const result = new Uint8Array(totalLength);\n\n  let offset = 0;\n  for (const arr of arrays) {\n    result.set(arr, offset);\n    offset += arr.length;\n  }\n\n  return result;\n}\n\nfunction hexToUint8Array(hex: string): Uint8Array {\n  const sanitisedHex = BigInt(hex).toString(16).padStart(64, \"0\");\n\n  const len = sanitisedHex.length / 2;\n  const u8 = new Uint8Array(len);\n\n  let i = 0;\n  let j = 0;\n  while (i < len) {\n    u8[i] = parseInt(sanitisedHex.slice(j, j + 2), 16);\n    i += 1;\n    j += 2;\n  }\n\n  return u8;\n}\n\n/**\n * Generates the prover data required for the Noir circuit.\n *\n * @param id - The user's identity string\n * @param pwd - The hashed password as a Uint8Array\n * @param stored_hash - The stored hash as a Uint8Array\n * @param tx - The transaction hash string\n * @returns An object containing the prover data\n */\nconst generateProverData = (\n  id: string,\n  pwd: Uint8Array,\n  stored_hash: Uint8Array,\n  tx: string,\n  blob_index: number,\n  tx_blob_count: number,\n): InputMap => {\n  const version = 1;\n  const initial_state = [0, 0, 0, 0];\n  const initial_state_len = initial_state.length;\n  const next_state = [0, 0, 0, 0];\n  const next_state_len = next_state.length;\n  const identity_len = id.length;\n  const identity = id.padEnd(256, \"0\");\n  const tx_hash = tx.padEnd(64, \"0\");\n  const tx_hash_len = tx_hash.length;\n  const index = blob_index;\n  const blob_number = 1;\n  const blob_contract_name_len = \"check_secret\".length;\n  const blob_contract_name = \"check_secret\".padEnd(256, \"0\");\n  const blob_capacity = 32;\n  const blob_len = 32;\n  const blob: number[] = Array.from(stored_hash);\n  const success = 1;\n  const password: number[] = Array.from(pwd);\n  assert(password.length == 32, \"Password length is not 32 bytes\");\n  assert(blob.length == blob_len, \"Blob length is not 32 bytes\");\n\n  return {\n    version,\n    initial_state,\n    initial_state_len,\n    next_state,\n    next_state_len,\n    identity,\n    identity_len,\n    tx_hash,\n    tx_hash_len,\n    index,\n    blob_number,\n    blob_index,\n    blob_contract_name_len,\n    blob_contract_name,\n    blob_capacity,\n    blob_len,\n    blob,\n    tx_blob_count,\n    success,\n    password,\n  };\n};\n"],"names":["base64Decode","input","c","defaultForeignCallHandler","name","args","parseErrorPayload","abi","originalError","payload","enrichedError","decodedPayload","abiDecodeError","generateWitness","compiledProgram","inputs","foreignCallHandler","witnessMap","abiEncode","executeProgram","err","Noir","circuit","__publicField","initAbi","initACVM","witness_stack","main_witness","returnValue","abiDecode","compressWitnessStack","hash_password","password","sha256","stringToBytes","identity_hash","identity","hashed_password_bytes","id_prefix","extended_id","computed_hash","build_blob","stored_hash","build_proof_transaction","tx_hash","blob_index","tx_blob_count","defaultCircuit","noir","backend","UltraHonkBackend","vk","witness","generateProverData","proof","reconstructedProof","reconstructHonkProof","flattenFieldsAsArray","register_contract","node","assert","condition","message","data","hashBuffer","encodeToHex","byte","fields","flattenedPublicInputs","hexToUint8Array","flattenUint8Arrays","arrays","totalLength","acc","val","result","offset","arr","hex","sanitisedHex","len","u8","i","j","id","pwd","tx","initial_state","initial_state_len","next_state","next_state_len","identity_len","tx_hash_len","index","blob_number","blob_contract_name_len","blob_contract_name","blob_capacity","blob_len","blob","success"],"mappings":"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","x_google_ignoreList":[0,1,2]}

package/dist/hyli-noir.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"hyli-noir.es.js","sources":["../node_modules/@noir-lang/noir_js/lib/base64_decode.mjs","../node_modules/@noir-lang/noir_js/lib/witness_generation.mjs","../node_modules/@noir-lang/noir_js/lib/program.mjs","../src/check_secret.ts"],"sourcesContent":["// Since this is a simple function, we can use feature detection to\n// see if we are in the nodeJs environment or the browser environment.\nexport function base64Decode(input) {\n    if (typeof Buffer !== 'undefined') {\n        // Node.js environment\n        return Buffer.from(input, 'base64');\n    }\n    else if (typeof atob === 'function') {\n        // Browser environment\n        return Uint8Array.from(atob(input), (c) => c.charCodeAt(0));\n    }\n    else {\n        throw new Error('No implementation found for base64 decoding.');\n    }\n}\n","import { abiDecodeError, abiEncode } from '@noir-lang/noirc_abi';\nimport { base64Decode } from \"./base64_decode.mjs\";\nimport { executeProgram } from '@noir-lang/acvm_js';\nconst defaultForeignCallHandler = async (name, args) => {\n    if (name == 'print') {\n        // By default we do not print anything for `print` foreign calls due to a need for formatting,\n        // however we provide an empty response in order to not halt execution.\n        //\n        // If a user needs to print values then they should provide a custom foreign call handler.\n        return [];\n    }\n    throw Error(`Unexpected oracle during execution: ${name}(${args.join(', ')})`);\n};\nfunction parseErrorPayload(abi, originalError) {\n    const payload = originalError.rawAssertionPayload;\n    if (!payload)\n        return originalError;\n    const enrichedError = originalError;\n    try {\n        // Decode the payload\n        const decodedPayload = abiDecodeError(abi, payload);\n        if (typeof decodedPayload === 'string') {\n            // If it's a string, just add it to the error message\n            enrichedError.message = `Circuit execution failed: ${decodedPayload}`;\n        }\n        else {\n            // If not, attach the payload to the original error\n            enrichedError.decodedAssertionPayload = decodedPayload;\n        }\n    }\n    catch (_errorDecoding) {\n        // Ignore errors decoding the payload\n    }\n    return enrichedError;\n}\n// Generates the witnesses needed to feed into the chosen proving system\nexport async function generateWitness(compiledProgram, inputs, foreignCallHandler = defaultForeignCallHandler) {\n    // Throws on ABI encoding error\n    const witnessMap = abiEncode(compiledProgram.abi, inputs);\n    // Execute the circuit to generate the rest of the witnesses and serialize\n    // them into a Uint8Array.\n    try {\n        const solvedWitness = await executeProgram(base64Decode(compiledProgram.bytecode), witnessMap, foreignCallHandler);\n        return solvedWitness;\n    }\n    catch (err) {\n        // Typescript types catched errors as unknown or any, so we need to narrow its type to check if it has raw assertion payload.\n        if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {\n            throw parseErrorPayload(compiledProgram.abi, err);\n        }\n        throw new Error(`Circuit execution failed: ${err}`);\n    }\n}\n","import { generateWitness } from \"./witness_generation.mjs\";\nimport initAbi, { abiDecode } from '@noir-lang/noirc_abi';\nimport initACVM, { compressWitnessStack } from '@noir-lang/acvm_js';\nexport class Noir {\n    circuit;\n    constructor(circuit) {\n        this.circuit = circuit;\n    }\n    /** @ignore */\n    async init() {\n        // If these are available, then we are in the\n        // web environment. For the node environment, this\n        // is a no-op.\n        if (typeof initAbi === 'function') {\n            await Promise.all([initAbi(), initACVM()]);\n        }\n    }\n    /**\n     * @description\n     * Allows to execute a circuit to get its witness and return value.\n     *\n     * @example\n     * ```typescript\n     * async execute(inputs)\n     * ```\n     */\n    async execute(inputs, foreignCallHandler) {\n        await this.init();\n        const witness_stack = await generateWitness(this.circuit, inputs, foreignCallHandler);\n        const main_witness = witness_stack[0].witness;\n        const { return_value: returnValue } = abiDecode(this.circuit.abi, main_witness);\n        return { witness: compressWitnessStack(witness_stack), returnValue };\n    }\n}\n","import { Noir } from \"@noir-lang/noir_js\";\nimport { reconstructHonkProof, UltraHonkBackend } from \"@aztec/bb.js\";\nimport { CompiledCircuit, InputMap } from \"@noir-lang/types\";\nimport { Blob, ProofTransaction, NodeApiHttpClient } from \"hyli\";\n\nexport const hash_password = async (password: string): Promise<Uint8Array> => {\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  return hashed_password_bytes;\n};\n\nexport const identity_hash = async (identity: string, password: string): Promise<string> => {\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  let encoder = new TextEncoder();\n  let id_prefix = encoder.encode(`${identity}:`);\n  let extended_id = new Uint8Array([...id_prefix, ...hashed_password_bytes]);\n  const computed_hash = await sha256(extended_id);\n  const computed_hash_hex = Buffer.from(computed_hash).toString(\"hex\");\n  return computed_hash_hex;\n};\n\n/**\n * Builds a blob transaction containing a secret derived from an identity and password.\n * The secret is constructed by:\n * 1. Hashing the password in order to have a fixed-size secret\n * 2. Concatenating the padded identity (to 64 chars) with ':' and the hashed password\n * 3. Hashing this combined value\n *\n * @param identity - The user's identity string\n * @param password - The user's password string\n * @returns A Promise resolving to a BlobTransaction containing the hashed secret\n */\nexport const build_blob = async (identity: string, password: string): Promise<Blob> => {\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  let encoder = new TextEncoder();\n  let id_prefix = encoder.encode(`${identity}:`);\n  let extended_id = new Uint8Array([...id_prefix, ...hashed_password_bytes]);\n  const stored_hash = await sha256(extended_id);\n\n  const secretBlob: Blob = {\n    contract_name: \"check_secret\",\n    data: Array.from(stored_hash),\n  };\n\n  return secretBlob;\n};\n\nimport defaultCircuit from \"../check-secret/target/check_secret.json\";\n\n/**\n * Builds a proof transaction by generating a zero-knowledge proof for checking a secret.\n * The proof demonstrates knowledge of a password that, when combined with an identity and hashed,\n * matches a stored hash value. The process involves:\n * 1. Hashing the password and combining it with the identity\n * 2. Generating a witness and proof using the UltraHonk backend\n * 3. Reconstructing and formatting the proof for the transaction\n *\n * @param identity - The user's identity string\n * @param password - The user's password string\n * @param tx_hash - The blob transaction hash string\n * @param circuit - The compiled Noir circuit (defaults to the check_secret circuit)\n * @returns A Promise resolving to a ProofTransaction containing the generated proof\n */\nexport const build_proof_transaction = async (\n  identity: string,\n  password: string,\n  tx_hash: string,\n  blob_index: number,\n  tx_blob_count: number,\n  circuit: CompiledCircuit = defaultCircuit as CompiledCircuit,\n): Promise<ProofTransaction> => {\n  const noir = new Noir(circuit);\n  const backend = new UltraHonkBackend(circuit.bytecode);\n  const vk = await backend.getVerificationKey();\n\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  let encoder = new TextEncoder();\n  let id_prefix = encoder.encode(`${identity}:`);\n  let extended_id = new Uint8Array([...id_prefix, ...hashed_password_bytes]);\n  const stored_hash = await sha256(extended_id);\n\n  const { witness } = await noir.execute(\n    generateProverData(identity, hashed_password_bytes, stored_hash, tx_hash, blob_index, tx_blob_count),\n  );\n\n  const proof = await backend.generateProof(witness);\n  const reconstructedProof = reconstructHonkProof(flattenFieldsAsArray(proof.publicInputs), proof.proof);\n\n  return {\n    contract_name: \"check_secret\",\n    program_id: Array.from(vk),\n    verifier: \"noir\",\n    proof: Array.from(reconstructedProof),\n  };\n};\n\n/**\n * Registers the Noir contract with the node if it is not already registered.\n * The contract is identified by its name \"check_secret\".\n * If the contract is not found, it registers the contract using the provided circuit.\n *\n * @param node - The NodeApiHttpClient instance to interact with the NodeApiHttpClient\n * @param circuit - The compiled Noir circuit (defaults to the check_secret circuit)\n * @returns A Promise that resolves when the contract is registered\n */\nexport const register_contract = async (\n  node: NodeApiHttpClient,\n  circuit: CompiledCircuit = defaultCircuit as CompiledCircuit,\n): Promise<void> => {\n  await node.getContract(\"check_secret\").catch(async () => {\n    const backend = new UltraHonkBackend(circuit.bytecode);\n\n    const vk = await backend.getVerificationKey();\n\n    await node.registerContract({\n      verifier: \"noir\",\n      program_id: Array.from(vk),\n      state_commitment: [0, 0, 0, 0],\n      contract_name: \"check_secret\",\n    });\n  });\n};\n\n// ---- Utility functions ----\n\nexport const assert = (condition: boolean, message: string): void => {\n  if (!condition) {\n    throw new Error(message);\n  }\n};\n\nexport const sha256 = async (data: Uint8Array): Promise<Uint8Array> => {\n  const hashBuffer = await crypto.subtle.digest(\"SHA-256\", data);\n  return new Uint8Array(hashBuffer);\n};\n\nexport const stringToBytes = (input: string): Uint8Array => {\n  return new TextEncoder().encode(input);\n};\n\nexport const encodeToHex = (data: Uint8Array): string => {\n  return Array.from(data)\n    .map((byte) => byte.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n};\n\nexport function flattenFieldsAsArray(fields: string[]): Uint8Array {\n  const flattenedPublicInputs = fields.map(hexToUint8Array);\n  return flattenUint8Arrays(flattenedPublicInputs);\n}\n\nfunction flattenUint8Arrays(arrays: Uint8Array[]): Uint8Array {\n  const totalLength = arrays.reduce((acc, val) => acc + val.length, 0);\n  const result = new Uint8Array(totalLength);\n\n  let offset = 0;\n  for (const arr of arrays) {\n    result.set(arr, offset);\n    offset += arr.length;\n  }\n\n  return result;\n}\n\nfunction hexToUint8Array(hex: string): Uint8Array {\n  const sanitisedHex = BigInt(hex).toString(16).padStart(64, \"0\");\n\n  const len = sanitisedHex.length / 2;\n  const u8 = new Uint8Array(len);\n\n  let i = 0;\n  let j = 0;\n  while (i < len) {\n    u8[i] = parseInt(sanitisedHex.slice(j, j + 2), 16);\n    i += 1;\n    j += 2;\n  }\n\n  return u8;\n}\n\n/**\n * Generates the prover data required for the Noir circuit.\n *\n * @param id - The user's identity string\n * @param pwd - The hashed password as a Uint8Array\n * @param stored_hash - The stored hash as a Uint8Array\n * @param tx - The transaction hash string\n * @returns An object containing the prover data\n */\nconst generateProverData = (\n  id: string,\n  pwd: Uint8Array,\n  stored_hash: Uint8Array,\n  tx: string,\n  blob_index: number,\n  tx_blob_count: number,\n): InputMap => {\n  const version = 1;\n  const initial_state = [0, 0, 0, 0];\n  const initial_state_len = initial_state.length;\n  const next_state = [0, 0, 0, 0];\n  const next_state_len = next_state.length;\n  const identity_len = id.length;\n  const identity = id.padEnd(256, \"0\");\n  const tx_hash = tx.padEnd(64, \"0\");\n  const tx_hash_len = tx_hash.length;\n  const index = blob_index;\n  const blob_number = 1;\n  const blob_contract_name_len = \"check_secret\".length;\n  const blob_contract_name = \"check_secret\".padEnd(256, \"0\");\n  const blob_capacity = 32;\n  const blob_len = 32;\n  const blob: number[] = Array.from(stored_hash);\n  const success = 1;\n  const password: number[] = Array.from(pwd);\n  assert(password.length == 32, \"Password length is not 32 bytes\");\n  assert(blob.length == blob_len, \"Blob length is not 32 bytes\");\n\n  return {\n    version,\n    initial_state,\n    initial_state_len,\n    next_state,\n    next_state_len,\n    identity,\n    identity_len,\n    tx_hash,\n    tx_hash_len,\n    index,\n    blob_number,\n    blob_index,\n    blob_contract_name_len,\n    blob_contract_name,\n    blob_capacity,\n    blob_len,\n    blob,\n    tx_blob_count,\n    success,\n    password,\n  };\n};\n"],"names":["base64Decode","input","c","defaultForeignCallHandler","name","args","parseErrorPayload","abi","originalError","payload","enrichedError","decodedPayload","abiDecodeError","generateWitness","compiledProgram","inputs","foreignCallHandler","witnessMap","abiEncode","executeProgram","err","Noir","circuit","__publicField","initAbi","initACVM","witness_stack","main_witness","returnValue","abiDecode","compressWitnessStack","hash_password","password","sha256","stringToBytes","identity_hash","identity","hashed_password_bytes","id_prefix","extended_id","computed_hash","build_blob","stored_hash","build_proof_transaction","tx_hash","blob_index","tx_blob_count","defaultCircuit","noir","backend","UltraHonkBackend","vk","witness","generateProverData","proof","reconstructedProof","reconstructHonkProof","flattenFieldsAsArray","register_contract","node","assert","condition","message","data","hashBuffer","encodeToHex","byte","fields","flattenedPublicInputs","hexToUint8Array","flattenUint8Arrays","arrays","totalLength","acc","val","result","offset","arr","hex","sanitisedHex","len","u8","i","j","id","pwd","tx","initial_state","initial_state_len","next_state","next_state_len","identity_len","tx_hash_len","index","blob_number","blob_contract_name_len","blob_contract_name","blob_capacity","blob_len","blob","success"],"mappings":"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","x_google_ignoreList":[0,1,2]}
+{"version":3,"file":"hyli-noir.es.js","sources":["../node_modules/@noir-lang/noir_js/lib/base64_decode.mjs","../node_modules/@noir-lang/noir_js/lib/witness_generation.mjs","../node_modules/@noir-lang/noir_js/lib/program.mjs","../src/check_secret.ts"],"sourcesContent":["// Since this is a simple function, we can use feature detection to\n// see if we are in the nodeJs environment or the browser environment.\nexport function base64Decode(input) {\n    if (typeof Buffer !== 'undefined') {\n        // Node.js environment\n        return Buffer.from(input, 'base64');\n    }\n    else if (typeof atob === 'function') {\n        // Browser environment\n        return Uint8Array.from(atob(input), (c) => c.charCodeAt(0));\n    }\n    else {\n        throw new Error('No implementation found for base64 decoding.');\n    }\n}\n","import { abiDecodeError, abiEncode } from '@noir-lang/noirc_abi';\nimport { base64Decode } from \"./base64_decode.mjs\";\nimport { executeProgram } from '@noir-lang/acvm_js';\nconst defaultForeignCallHandler = async (name, args) => {\n    if (name == 'print') {\n        // By default we do not print anything for `print` foreign calls due to a need for formatting,\n        // however we provide an empty response in order to not halt execution.\n        //\n        // If a user needs to print values then they should provide a custom foreign call handler.\n        return [];\n    }\n    throw Error(`Unexpected oracle during execution: ${name}(${args.join(', ')})`);\n};\nfunction parseErrorPayload(abi, originalError) {\n    const payload = originalError.rawAssertionPayload;\n    if (!payload)\n        return originalError;\n    const enrichedError = originalError;\n    try {\n        // Decode the payload\n        const decodedPayload = abiDecodeError(abi, payload);\n        if (typeof decodedPayload === 'string') {\n            // If it's a string, just add it to the error message\n            enrichedError.message = `Circuit execution failed: ${decodedPayload}`;\n        }\n        else {\n            // If not, attach the payload to the original error\n            enrichedError.decodedAssertionPayload = decodedPayload;\n        }\n    }\n    catch (_errorDecoding) {\n        // Ignore errors decoding the payload\n    }\n    return enrichedError;\n}\n// Generates the witnesses needed to feed into the chosen proving system\nexport async function generateWitness(compiledProgram, inputs, foreignCallHandler = defaultForeignCallHandler) {\n    // Throws on ABI encoding error\n    const witnessMap = abiEncode(compiledProgram.abi, inputs);\n    // Execute the circuit to generate the rest of the witnesses and serialize\n    // them into a Uint8Array.\n    try {\n        const solvedWitness = await executeProgram(base64Decode(compiledProgram.bytecode), witnessMap, foreignCallHandler);\n        return solvedWitness;\n    }\n    catch (err) {\n        // Typescript types catched errors as unknown or any, so we need to narrow its type to check if it has raw assertion payload.\n        if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {\n            throw parseErrorPayload(compiledProgram.abi, err);\n        }\n        throw new Error(`Circuit execution failed: ${err}`);\n    }\n}\n","import { generateWitness } from \"./witness_generation.mjs\";\nimport initAbi, { abiDecode } from '@noir-lang/noirc_abi';\nimport initACVM, { compressWitnessStack } from '@noir-lang/acvm_js';\nexport class Noir {\n    circuit;\n    constructor(circuit) {\n        this.circuit = circuit;\n    }\n    /** @ignore */\n    async init() {\n        // If these are available, then we are in the\n        // web environment. For the node environment, this\n        // is a no-op.\n        if (typeof initAbi === 'function') {\n            await Promise.all([initAbi(), initACVM()]);\n        }\n    }\n    /**\n     * @description\n     * Allows to execute a circuit to get its witness and return value.\n     *\n     * @example\n     * ```typescript\n     * async execute(inputs)\n     * ```\n     */\n    async execute(inputs, foreignCallHandler) {\n        await this.init();\n        const witness_stack = await generateWitness(this.circuit, inputs, foreignCallHandler);\n        const main_witness = witness_stack[0].witness;\n        const { return_value: returnValue } = abiDecode(this.circuit.abi, main_witness);\n        return { witness: compressWitnessStack(witness_stack), returnValue };\n    }\n}\n","import { Noir } from \"@noir-lang/noir_js\";\nimport { reconstructHonkProof, UltraHonkBackend } from \"@aztec/bb.js\";\nimport { CompiledCircuit, InputMap } from \"@noir-lang/types\";\nimport { Blob, ProofTransaction, NodeApiHttpClient } from \"hyli\";\n\n/**\n * Hashes a password using SHA-256.\n * The password is converted to a Uint8Array and hashed using SHA-256.\n * The resulting hash is returned as a Uint8Array.\n *\n * @param password - The password string to hash\n * @returns A Promise resolving to the Uint8Array of the computed hash\n */\nexport const hash_password = async (password: string): Promise<Uint8Array> => {\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  return hashed_password_bytes;\n};\n\n/**\n * Hashes an identity and password together using SHA-256.\n * The identity is concatenated with ':' and the hashed password.\n * The resulting combined value is hashed again using SHA-256.\n * The resulting hash is returned as a hexadecimal string that can be \n * stored publicly.\n * \n * This function is mainly used to check the given password against a stored hash.\n *\n * @param identity - The user's identity string\n * @param password - The user's password string\n * @returns A Promise resolving to the hexadecimal string of the computed hash\n */\nexport const identity_hash = async (identity: string, password: string): Promise<string> => {\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  let encoder = new TextEncoder();\n  let id_prefix = encoder.encode(`${identity}:`);\n  let extended_id = new Uint8Array([...id_prefix, ...hashed_password_bytes]);\n  const computed_hash = await sha256(extended_id);\n  const computed_hash_hex = Buffer.from(computed_hash).toString(\"hex\");\n  return computed_hash_hex;\n};\n\n/**\n * Builds a blob transaction containing a secret derived from an identity and password.\n * The secret is constructed by:\n * 1. Hashing the password in order to have a fixed-size secret\n * 2. Concatenating the padded identity (to 64 chars) with ':' and the hashed password\n * 3. Hashing this combined value\n *\n * @param identity - The user's identity string\n * @param password - The user's password string\n * @returns A Promise resolving to a BlobTransaction containing the hashed secret\n */\nexport const build_blob = async (identity: string, password: string): Promise<Blob> => {\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  let encoder = new TextEncoder();\n  let id_prefix = encoder.encode(`${identity}:`);\n  let extended_id = new Uint8Array([...id_prefix, ...hashed_password_bytes]);\n  const stored_hash = await sha256(extended_id);\n\n  const secretBlob: Blob = {\n    contract_name: \"check_secret\",\n    data: Array.from(stored_hash),\n  };\n\n  return secretBlob;\n};\n\nimport defaultCircuit from \"../check-secret/target/check_secret.json\";\n\n/**\n * Builds a proof transaction by generating a zero-knowledge proof for checking a secret.\n * The proof demonstrates knowledge of a password that, when combined with an identity and hashed,\n * matches a stored hash value. The process involves:\n * 1. Hashing the password and combining it with the identity\n * 2. Generating a witness and proof using the UltraHonk backend\n * 3. Reconstructing and formatting the proof for the transaction\n *\n * @param identity - The user's identity string\n * @param password - The user's password string\n * @param tx_hash - The blob transaction hash string\n * @param circuit - The compiled Noir circuit (defaults to the check_secret circuit)\n * @returns A Promise resolving to a ProofTransaction containing the generated proof\n */\nexport const build_proof_transaction = async (\n  identity: string,\n  password: string,\n  tx_hash: string,\n  blob_index: number,\n  tx_blob_count: number,\n  circuit: CompiledCircuit = defaultCircuit as CompiledCircuit,\n): Promise<ProofTransaction> => {\n  const noir = new Noir(circuit);\n  const backend = new UltraHonkBackend(circuit.bytecode);\n  const vk = await backend.getVerificationKey();\n\n  const hashed_password_bytes = await sha256(stringToBytes(password));\n  let encoder = new TextEncoder();\n  let id_prefix = encoder.encode(`${identity}:`);\n  let extended_id = new Uint8Array([...id_prefix, ...hashed_password_bytes]);\n  const stored_hash = await sha256(extended_id);\n\n  const { witness } = await noir.execute(\n    generateProverData(identity, hashed_password_bytes, stored_hash, tx_hash, blob_index, tx_blob_count),\n  );\n\n  const proof = await backend.generateProof(witness);\n  const reconstructedProof = reconstructHonkProof(flattenFieldsAsArray(proof.publicInputs), proof.proof);\n\n  return {\n    contract_name: \"check_secret\",\n    program_id: Array.from(vk),\n    verifier: \"noir\",\n    proof: Array.from(reconstructedProof),\n  };\n};\n\n/**\n * Registers the Noir contract with the node if it is not already registered.\n * The contract is identified by its name \"check_secret\".\n * If the contract is not found, it registers the contract using the provided circuit.\n *\n * @param node - The NodeApiHttpClient instance to interact with the NodeApiHttpClient\n * @param circuit - The compiled Noir circuit (defaults to the check_secret circuit)\n * @returns A Promise that resolves when the contract is registered\n */\nexport const register_contract = async (\n  node: NodeApiHttpClient,\n  circuit: CompiledCircuit = defaultCircuit as CompiledCircuit,\n): Promise<void> => {\n  await node.getContract(\"check_secret\").catch(async () => {\n    const backend = new UltraHonkBackend(circuit.bytecode);\n\n    const vk = await backend.getVerificationKey();\n\n    await node.registerContract({\n      verifier: \"noir\",\n      program_id: Array.from(vk),\n      state_commitment: [0, 0, 0, 0],\n      contract_name: \"check_secret\",\n    });\n  });\n};\n\n// ---- Utility functions ----\n\nexport const assert = (condition: boolean, message: string): void => {\n  if (!condition) {\n    throw new Error(message);\n  }\n};\n\nexport const sha256 = async (data: Uint8Array): Promise<Uint8Array> => {\n  const hashBuffer = await crypto.subtle.digest(\"SHA-256\", data);\n  return new Uint8Array(hashBuffer);\n};\n\nexport const stringToBytes = (input: string): Uint8Array => {\n  return new TextEncoder().encode(input);\n};\n\nexport const encodeToHex = (data: Uint8Array): string => {\n  return Array.from(data)\n    .map((byte) => byte.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n};\n\nexport function flattenFieldsAsArray(fields: string[]): Uint8Array {\n  const flattenedPublicInputs = fields.map(hexToUint8Array);\n  return flattenUint8Arrays(flattenedPublicInputs);\n}\n\nfunction flattenUint8Arrays(arrays: Uint8Array[]): Uint8Array {\n  const totalLength = arrays.reduce((acc, val) => acc + val.length, 0);\n  const result = new Uint8Array(totalLength);\n\n  let offset = 0;\n  for (const arr of arrays) {\n    result.set(arr, offset);\n    offset += arr.length;\n  }\n\n  return result;\n}\n\nfunction hexToUint8Array(hex: string): Uint8Array {\n  const sanitisedHex = BigInt(hex).toString(16).padStart(64, \"0\");\n\n  const len = sanitisedHex.length / 2;\n  const u8 = new Uint8Array(len);\n\n  let i = 0;\n  let j = 0;\n  while (i < len) {\n    u8[i] = parseInt(sanitisedHex.slice(j, j + 2), 16);\n    i += 1;\n    j += 2;\n  }\n\n  return u8;\n}\n\n/**\n * Generates the prover data required for the Noir circuit.\n *\n * @param id - The user's identity string\n * @param pwd - The hashed password as a Uint8Array\n * @param stored_hash - The stored hash as a Uint8Array\n * @param tx - The transaction hash string\n * @returns An object containing the prover data\n */\nconst generateProverData = (\n  id: string,\n  pwd: Uint8Array,\n  stored_hash: Uint8Array,\n  tx: string,\n  blob_index: number,\n  tx_blob_count: number,\n): InputMap => {\n  const version = 1;\n  const initial_state = [0, 0, 0, 0];\n  const initial_state_len = initial_state.length;\n  const next_state = [0, 0, 0, 0];\n  const next_state_len = next_state.length;\n  const identity_len = id.length;\n  const identity = id.padEnd(256, \"0\");\n  const tx_hash = tx.padEnd(64, \"0\");\n  const tx_hash_len = tx_hash.length;\n  const index = blob_index;\n  const blob_number = 1;\n  const blob_contract_name_len = \"check_secret\".length;\n  const blob_contract_name = \"check_secret\".padEnd(256, \"0\");\n  const blob_capacity = 32;\n  const blob_len = 32;\n  const blob: number[] = Array.from(stored_hash);\n  const success = 1;\n  const password: number[] = Array.from(pwd);\n  assert(password.length == 32, \"Password length is not 32 bytes\");\n  assert(blob.length == blob_len, \"Blob length is not 32 bytes\");\n\n  return {\n    version,\n    initial_state,\n    initial_state_len,\n    next_state,\n    next_state_len,\n    identity,\n    identity_len,\n    tx_hash,\n    tx_hash_len,\n    index,\n    blob_number,\n    blob_index,\n    blob_contract_name_len,\n    blob_contract_name,\n    blob_capacity,\n    blob_len,\n    blob,\n    tx_blob_count,\n    success,\n    password,\n  };\n};\n"],"names":["base64Decode","input","c","defaultForeignCallHandler","name","args","parseErrorPayload","abi","originalError","payload","enrichedError","decodedPayload","abiDecodeError","generateWitness","compiledProgram","inputs","foreignCallHandler","witnessMap","abiEncode","executeProgram","err","Noir","circuit","__publicField","initAbi","initACVM","witness_stack","main_witness","returnValue","abiDecode","compressWitnessStack","hash_password","password","sha256","stringToBytes","identity_hash","identity","hashed_password_bytes","id_prefix","extended_id","computed_hash","build_blob","stored_hash","build_proof_transaction","tx_hash","blob_index","tx_blob_count","defaultCircuit","noir","backend","UltraHonkBackend","vk","witness","generateProverData","proof","reconstructedProof","reconstructHonkProof","flattenFieldsAsArray","register_contract","node","assert","condition","message","data","hashBuffer","encodeToHex","byte","fields","flattenedPublicInputs","hexToUint8Array","flattenUint8Arrays","arrays","totalLength","acc","val","result","offset","arr","hex","sanitisedHex","len","u8","i","j","id","pwd","tx","initial_state","initial_state_len","next_state","next_state_len","identity_len","tx_hash_len","index","blob_number","blob_contract_name_len","blob_contract_name","blob_capacity","blob_len","blob","success"],"mappings":"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","x_google_ignoreList":[0,1,2]}

package/package.json

@@ -6,11 +6,11 @@
     "url": "https://github.com/hyli-org/hyli-noir.git"
   },
   "bugs": {
-    "url": "https://github.com/hyli-org/wallet/issues"
+    "url": "https://github.com/hyli-org/hyli-noir/issues"
   },
   "author": "Hyli",
   "license": "MIT",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "type": "module",
   "main": "dist/hyli-noir.cjs.js",
   "module": "dist/hyli-noir.es.js",