enyal-sdk 2.1.0__tar.gz

enyal-sdk-2.1.0/LICENSE

@@ -0,0 +1,208 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+---
+
+Copyright 2026 Greenland AI Limited
+
+Licensed under the Apache License, Version 2.0.

enyal-sdk-2.1.0/PKG-INFO

@@ -0,0 +1,409 @@
+Metadata-Version: 2.1
+Name: enyal-sdk
+Version: 2.1.0
+Summary: ENYAL SDK — encrypted knowledge graph, local memory, permanent proof
+Author-email: Greenland AI Limited <info@enyal.ai>
+License: Apache-2.0
+Project-URL: Homepage, https://enyal.ai
+Project-URL: Documentation, https://enyal.ai/docs
+Project-URL: Repository, https://github.com/JoulePAI/enyal-sdk-python
+Keywords: enyal,knowledge-graph,zero-knowledge,archival,sdk
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: crypto
+Requires-Dist: cryptography>=41.0; extra == "crypto"
+Provides-Extra: llm
+Requires-Dist: httpx>=0.24; extra == "llm"
+Provides-Extra: all
+Requires-Dist: cryptography>=41.0; extra == "all"
+Requires-Dist: httpx>=0.24; extra == "all"
+
+# ENYAL SDK
+
+Your agent thinks locally. ENYAL proves permanently.
+
+## Quick Start — Local Knowledge + Permanent Proof
+
+```python
+from enyal_sdk import EnyalAgent
+
+agent = EnyalAgent(api_key="eyl_your_key")
+
+# Remember locally (free, private, instant)
+agent.remember("Tesla has 100GWh battery capacity",
+               node_type="entity",
+               properties={"frontier": "energy", "capacity": "100GWh"})
+
+agent.remember("SpaceX launches 90 rockets per year",
+               node_type="entity",
+               properties={"frontier": "space", "launches": 90})
+
+# Recall from local memory
+results = agent.recall("battery capacity")
+
+# Check what you know
+health = agent.health()
+print(health)
+# {"status": "healthy", "total_nodes": 2, "contradictions": 0}
+
+# Get compact context for your AI prompt (120 tokens)
+context = agent.compact()
+print(context)
+# E:Tesla|100GWh battery capacity|0c
+# E:SpaceX|90 launches per year|0c
+
+# Archive permanently (costs joules, encrypted, provable)
+agent.archive(
+    chunk_type="decision_record",
+    chunk_key="my-agent:decision:invest-energy",
+    data={"decision": "Invest in energy infrastructure",
+          "confidence": 0.85,
+          "entities": ["Tesla"]}
+)
+
+# Sync local brain to ENYAL for backup
+agent.sync_to_enyal()
+
+# Pull remote knowledge locally
+agent.sync_from_enyal()
+```
+
+## Retry Safety
+
+All state-changing API calls automatically retry on network errors, timeouts, 5xx, and 429 (rate limit) responses. Retries use exponential backoff with jitter and a deterministic idempotency key to prevent double-charges.
+
+```python
+# Automatic retry with SDK-generated idempotency key (default)
+agent.archive(chunk_type="decision_record",
+              chunk_key="my-agent:decision:001",
+              data={"decision": "Invest in space"})
+
+# Explicit idempotency key (e.g., your own dedup token)
+agent.archive(chunk_type="decision_record",
+              chunk_key="my-agent:decision:001",
+              data={"decision": "Invest in space"},
+              idempotency_key="my-dedup-key-12345678901234567890")
+
+# Disable retry for a single call
+agent.archive(..., retry=False)
+```
+
+**Default retry policy:** 3 retries, 0.5s initial delay, 2x backoff, 8s max delay, 0.1-0.3s jitter. Respects `Retry-After` header on 429 responses. Never retries 4xx errors (except 429).
+
+**Retry-safe endpoints:** archive, prove, disclose, client-side disclose, share-proof, timestamp, agreement/create, compliance/attest, message/send.
+
+**Not available via SDK:** `knowledge/synthesise` requires session auth (web console only).
+
+## Two Layers
+
+| Feature | Local (free) | ENYAL (paid) |
+|---------|-------------|--------------|
+| Storage | SQLite on your machine | Permanent cryptographic ledger |
+| Speed | Instant | ~200ms |
+| Privacy | Never leaves your device | Encrypted, you hold the key |
+| Proof | None | ZK proofs, BSV settlement |
+| Cost | Free | Joules per operation |
+| Persistence | Until you delete it | Permanent, immutable |
+
+## Installation
+
+```bash
+pip install enyal-sdk
+```
+
+If using natural language `remember()` with a local LLM:
+
+- Install Ollama: https://ollama.com
+- Pull a model: `ollama pull mistral-nemo`
+- Or set `ENYAL_LOCAL_MODEL=your-model-name`
+- Without a pulled model, extraction falls back to using the full text as the entity name (10s timeout)
+
+### Node.js
+
+```bash
+npm install enyal-sdk
+```
+
+```javascript
+const { EnyalAgent } = require('enyal-sdk');
+
+const agent = new EnyalAgent('eyl_your_key');
+
+// Local (free, private, instant, synchronous)
+agent.remember('SpaceX', 'entity', '90 launches/yr', { launches: 90 });
+const results = agent.recall('SpaceX');
+
+// Natural language (async, optional Ollama)
+await agent.rememberText('Tesla has 100GWh battery capacity');
+
+// Compact context for AI prompt
+const ctx = agent.compact();
+
+// Permanent proof (costs joules, async)
+await agent.archive('decision_record',
+    'my-agent:decision:001',
+    { decision: 'Invest in space', confidence: 0.85 });
+
+// Always close when done (releases SQLite file lock)
+agent.close();
+```
+
+## Backup & Restore
+
+```python
+from enyal_sdk import EnyalAgent
+
+agent = EnyalAgent(api_key="eyl_your_key")
+agent.remember("Tesla", "entity", "100GWh capacity", {"sector": "energy"})
+
+# Backup: encrypt locally, send to ENYAL
+agent.sync_to_enyal(password="your-enyal-password")
+# ENYAL stores an encrypted blob it cannot read
+
+# Restore on new device:
+new_agent = EnyalAgent(api_key="eyl_your_key")
+new_agent.restore_from_enyal(password="your-enyal-password")
+# Downloads encrypted snapshot, decrypts locally
+print(new_agent.health())
+```
+
+Your knowledge graph is portable and private:
+- Encrypted before it leaves your device
+- ENYAL stores the blob but can't read it
+- Only your password can decrypt it
+- Works across devices, platforms, and SDKs
+
+**Important:** Snapshots are encrypted with your current password. If you change your password, old snapshots become undecryptable. Re-sync immediately after any password change.
+
+### Limitations
+
+- Local knowledge uses SQLite WAL mode. Do not place the database file on a network filesystem (NFS/SMB).
+
+---
+
+## Client-Side Disclosure & Verification
+
+Client-side disclosure, verification, and proof generation for ENYAL's intelligence archival system.
+
+Three trust tiers — choose based on your security requirements:
+
+| Tier | Trust in ENYAL | What runs where | Use case |
+|------|----------------|-----------------|----------|
+| **Tier 1** | None | Everything client-side | Maximum security, auditor self-verification |
+| **Tier 2** | During proof generation | Proof on ENYAL's server | Third-party auditor proofs |
+| **Tier 3** | None | Self-hosted Rust binary | Zero-trust zero-knowledge proof generation |
+
+## Installation
+
+**JavaScript** — No npm packages required. Web Crypto API (browsers) or Node.js 19+.
+For ECDH, provide a P-256 scalar multiply function (e.g. from `@noble/curves`).
+
+**Python** — `pip install cryptography`
+
+## Usage
+
+### Tier 1 — Full client-side (zero trust)
+
+```js
+import { requestClientDisclosure, decryptCustodialShare, combineSharesAndDecrypt, verifyShareCombination } from './enyal-client.js';
+import { p256 } from '@noble/curves/p256';
+
+// P-256 scalar multiply helper for @noble/curves
+async function p256ScalarMul(privKeyBytes, compressedPubKey) {
+    const shared = p256.getSharedSecret(privKeyBytes, compressedPubKey, true);
+    return shared.slice(1, 33); // x-coordinate only
+}
+
+// 1. Request disclosure materials (no share sent to server)
+const materials = await requestClientDisclosure(apiKey, 'https://api.enyal.ai', ['chunk-id'], 'audit');
+
+// 2. Decrypt ENYAL's share using your private key
+const custodialShare = await decryptCustodialShare(materials.custodial_share, myPrivateKey, p256ScalarMul);
+
+// 3. Combine shares and decrypt the data
+const plaintext = await combineSharesAndDecrypt(myShare, custodialShare, materials.chunks[0], p256ScalarMul);
+
+// 4. Verify share combination locally (WASM, 78KB, zero server calls)
+const verification = await verifyShareCombination(myShare, custodialShare, materials.poseidon_key_hash);
+console.log(verification.valid); // true — verified locally, ENYAL never saw your share
+```
+
+```python
+from enyal_sdk import request_client_disclosure, decrypt_custodial_share, combine_shares_and_decrypt, verify_share_combination
+
+# 1. Request disclosure materials
+materials = request_client_disclosure(api_key, 'https://api.enyal.ai', ['chunk-id'], 'audit')
+
+# 2. Decrypt custodial share
+custodial_share = decrypt_custodial_share(materials['custodial_share'], my_private_key_bytes)
+
+# 3. Combine and decrypt
+plaintext = combine_shares_and_decrypt(my_share, custodial_share, materials['chunks'][0])
+
+# 4. Verify locally (requires shamir-circuit binary for content integrity hash)
+result = verify_share_combination(my_share, custodial_share, materials['poseidon_key_hash'],
+                                   binary_path='/path/to/shamir-circuit')
+print(result['valid'])  # True
+```
+
+### Tier 2 — Proof for auditors (share sent to server)
+
+```js
+import { requestShareProof } from './enyal-client.js';
+
+const proof = await requestShareProof(apiKey, 'https://api.enyal.ai', myShareHex);
+// proof.verified === true
+// proof.share_attestation.wiped === true
+// proof.share_attestation.trust_level === "operational_transparency"
+
+// Hand proof to auditor — they verify at enyal.ai/docs/verify
+```
+
+### Tier 3 — Self-hosted (zero trust, full zero-knowledge proof)
+
+```bash
+# Clone and build
+git clone https://github.com/GreenlandAI/shamir-circuit.git
+cd shamir-circuit && cargo build --release
+
+# Generate proof locally
+echo '{"command":"verify_share_combination","share1_hex":"01...","share2_hex":"02...","expected_poseidon_hash":"abcd..."}' \
+  | ./target/release/shamir-circuit
+
+# Your shares never leave your machine. Full zero-knowledge proof generated locally.
+```
+
+## Test Vector
+
+Use this to verify your GF(256) implementation produces identical results to ENYAL's.
+
+```
+Test key:    0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20
+Share 1:     010712cc64a718cdf5517aa4a7540d943eee4148c6a308d3147509e70e361e3672
+Share 2:     020d2286c45a3a88e9b9ea4e41bf08224cf4b4a5ab622a8400c13cf8384b1e4d84
+Share 3:     030b3249a4f8244214e19ae1eae60bb9620be7fe79d434400cad2f042a601e64d6
+Expected:    0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20
+```
+
+Combine any two shares → must reconstruct to `010203...1f20` (32 bytes).
+
+**JavaScript verification:**
+```js
+import { shamirCombine, hexToBytes, bytesToHex } from './enyal-client.js';
+
+const share1 = hexToBytes('010712cc64a718cdf5517aa4a7540d943eee4148c6a308d3147509e70e361e3672');
+const share2 = hexToBytes('020d2286c45a3a88e9b9ea4e41bf08224cf4b4a5ab622a8400c13cf8384b1e4d84');
+const secret = shamirCombine(share1, share2);
+console.log(bytesToHex(secret));
+// Expected: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20
+```
+
+**Python verification:**
+```python
+from enyal_sdk import shamir_combine
+
+share1 = bytes.fromhex('010712cc64a718cdf5517aa4a7540d943eee4148c6a308d3147509e70e361e3672')
+share2 = bytes.fromhex('020d2286c45a3a88e9b9ea4e41bf08224cf4b4a5ab622a8400c13cf8384b1e4d84')
+secret = shamir_combine(share1, share2)
+print(secret.hex())
+# Expected: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20
+```
+
+## Agent Messaging
+
+Send encrypted messages between agents. Messages are archived as immutable chunks — the chain proves existence, the relay proves order. Send costs 10 joules; inbox/thread/read are free.
+
+**JavaScript:**
+```js
+import { sendMessage, getInbox, getThread, markRead } from './enyal-client.js';
+
+// Send a trade offer
+const msg = await sendMessage(apiKey, {
+    senderAgentId: 'agent-alpha',
+    threadId: 'a1b2c3d4-e5f6-7890-abcd-ef1234567890', // use match_id for RAREEAI trades
+    recipientAgentId: 'agent-beta',
+    messageType: 'offer',
+    payload: { resource: 'compute_4gpu', price: 500, duration_hours: 24 },
+});
+// msg.sequence_number === 1, msg.chunk_id archived on-chain
+
+// Check inbox
+const inbox = await getInbox(apiKey, { agentId: 'agent-beta' });
+// inbox.messages[0].delivered_at set automatically
+
+// Check outbox (what did I send?)
+const sent = await getInbox(apiKey, { agentId: 'agent-alpha', direction: 'outbox' });
+
+// Full thread view (both sides)
+const thread = await getThread(apiKey, { threadId: msg.thread_id });
+// thread.messages ordered by sequence_number
+
+// Mark as read
+await markRead(apiKey, { messageIds: [inbox.messages[0].message_id] });
+```
+
+**Python:**
+```python
+from enyal_sdk import send_message, get_inbox, get_thread, mark_read
+
+# Send a trade offer
+msg = send_message(api_key, 'agent-alpha',
+                   'a1b2c3d4-e5f6-7890-abcd-ef1234567890',
+                   'agent-beta', 'offer',
+                   {'resource': 'compute_4gpu', 'price': 500, 'duration_hours': 24})
+
+# Check inbox
+inbox = get_inbox(api_key, 'agent-beta')
+
+# Check outbox
+sent = get_inbox(api_key, 'agent-alpha', direction='outbox')
+
+# Full thread view
+thread = get_thread(api_key, msg['thread_id'])
+
+# Mark as read
+mark_read(api_key, [inbox['messages'][0]['message_id']])
+```
+
+**Message types:** `offer`, `bid`, `counter`, `accept`, `reject`, `inform`, `delivery_notice`, `general`
+
+**Rate limits:** Free 20/hour, Pro 100/hour, Enterprise 1000/hour per agent.
+
+## Error Handling
+
+Wrong share or recovery phrase produces a clear error — raw crypto exceptions are never exposed:
+
+```
+Share combination failed — invalid recovery phrase or share.
+Please verify your recovery phrase and try again.
+```
+
+This happens when: Shamir combine produces wrong key → ECDH derives wrong shared secret → AES-GCM auth tag verification fails.
+
+## WASM Module
+
+The share verification WASM module (78 KB) provides:
+- `verify_share_combination(share1_hex, share2_hex, expected_hash_hex)` → JSON result
+- `poseidon_hash_hex(data_hex)` → 64-char content integrity hash
+
+Deployed at: `https://enyal.ai/static/shamir_verify.wasm`
+
+## Trust Model
+
+| Component | What ENYAL sees | What auditor sees |
+|---|---|---|
+| **Tier 1** client-side | Encrypted chunks only | Decrypted data + local verification |
+| **Tier 2** share proof | Customer share (wiped after proof) | Zero-knowledge proof of valid combination |
+| **Tier 3** self-hosted | Nothing | Zero-knowledge proof generated on own hardware |
+
+Tier 2 share attestation is operational transparency — ENYAL self-reports share handling.
+A malicious operator could copy the share before wiping. The attestation raises the cost
+of misbehaviour but does not prevent it. Only Tier 3 prevents share exposure entirely.