@permissionless-technologies/upp-sdk 0.1.0

package/dist/indexer/index.d.cts

@@ -0,0 +1,206 @@
+import { S as StorageAdapter } from '../index-C-jSNw6j.cjs';
+export { C as CommitmentInsertedArgs, a as IndexedNote, I as Indexer, f as IndexerState, L as LiveSyncConfig, b as NoteFilters, N as NoteStatus, j as NullifiedArgs, R as RpcIndexerConfig, h as SerializedNote, i as StealthTransactArgs, e as SyncConfig, d as SyncProgress, c as SyncResult, g as SyncState } from '../index-C-jSNw6j.cjs';
+import { _ as ___index_js } from '../index-BGvapsJy.cjs';
+export { m as makeRpcIndexer } from '../index-BGvapsJy.cjs';
+import { Hex } from 'viem';
+import { P as Point } from '../merkle-mteVOlDf.cjs';
+import '../transfer-DKZuJnRM.cjs';
+import '../keccak-m31-B_AqBbRF.cjs';
+import '@permissionless-technologies/upc-sdk';
+import 'react/jsx-runtime';
+import 'react';
+import '../types-CJSbxv4q.cjs';
+import '../keys/index.cjs';
+import '../utils/index.cjs';
+
+interface DecryptedNote {
+    amount: bigint;
+    blinding: bigint;
+    oneTimeSecret: bigint;
+    oneTimePubkey: Point;
+    origin: bigint;
+    token: bigint;
+}
+interface UnpackedNoteData {
+    searchTag: bigint;
+    ephemeralPubkeyX: bigint;
+    ephemeralPubkeyY: bigint;
+    encryptedNote: Hex;
+}
+interface DecryptionKeys {
+    spendingSecret: bigint;
+    spendingPubkey: Point;
+    masterViewingSecret: bigint;
+    masterViewingPubKey: Point;
+}
+type SDK = typeof ___index_js;
+/**
+ * Compute the expected search tag for a given ephemeral public key
+ *
+ * The search tag is computed as: Poseidon(viewingSharedSecret.x, 0) & ((1n << 64n) - 1n)
+ * This must match how search tags are computed during note creation in createUPPNote().
+ *
+ * - DVK is the derived viewing key (derived from master viewing key using R.x as nonce)
+ * - R is the ephemeral public key
+ * - viewingSharedSecret = DVK * R
+ *
+ * This allows quick filtering of events before expensive trial decryption.
+ */
+declare function computeSearchTag(sdk: SDK, masterViewingSecret: bigint, masterViewingPubKey: Point, ephemeralPubkey: Point, debug?: boolean): Promise<bigint>;
+/**
+ * Check if a search tag from an event matches our viewing key
+ *
+ * This is a fast check that can filter out 99%+ of events before
+ * attempting expensive trial decryption.
+ *
+ * @param eventSearchTag - The search tag from the event (8 bytes as bigint)
+ * @param sdk - The loaded SDK module
+ * @param masterViewingSecret - Our master viewing secret
+ * @param masterViewingPubKey - Our master viewing public key
+ * @param ephemeralPubkey - The ephemeral public key from the event
+ * @param debug - Enable debug logging
+ * @returns true if the search tag matches (event might be ours)
+ */
+declare function matchesSearchTag(eventSearchTag: bigint, sdk: SDK, masterViewingSecret: bigint, masterViewingPubKey: Point, ephemeralPubkey: Point, debug?: boolean): Promise<boolean>;
+/**
+ * Try to decrypt a note using dual ECDH (UPP format with origin and token)
+ *
+ * 1. Viewing ECDH: DVK * R → AES decryption key (viewing shared secret)
+ * 2. Spending ECDH: spendingSecret * R → one-time key for commitment verification
+ *
+ * DVK is derived using R.x (ephemeral public key x-coordinate) as the nonce.
+ *
+ * UPP encrypted payload: amount (32) + blinding (32) + origin (20) + token (20) = 104 bytes
+ * UPP commitment: Poseidon(amount, pubkeyX, pubkeyY, blinding, origin, token)
+ *
+ * @param sdk - The loaded SDK module
+ * @param keys - Decryption keys (spending and viewing)
+ * @param ephemeralPubkey - The ephemeral public key from the event
+ * @param encryptedNote - The encrypted note data
+ * @param expectedCommitment - The commitment to verify against
+ * @param debug - Enable debug logging
+ * @returns Decrypted note data or null if decryption/verification failed
+ */
+declare function tryDecryptNote(sdk: SDK, keys: DecryptionKeys, ephemeralPubkey: Point, encryptedNote: Hex, expectedCommitment: bigint, debug?: boolean): Promise<DecryptedNote | null>;
+/**
+ * Unpack note data from packed on-chain format
+ *
+ * Format: searchTag (8 bytes) + ephemeralPubkeyX (32 bytes) + ephemeralPubkeyY (32 bytes) + encryptedNote (variable)
+ *
+ * @param packed - The packed note data from the event
+ * @param debug - Enable debug logging
+ * @returns Unpacked note data or null if format is invalid
+ */
+declare function unpackNoteData(packed: Hex, debug?: boolean): UnpackedNoteData | null;
+
+/**
+ * IndexedDB Storage Adapter
+ *
+ * Provides persistent storage using IndexedDB for browser environments.
+ * This is the default and recommended storage adapter for production use.
+ *
+ * Benefits:
+ * - Large capacity (no 5MB limit like localStorage)
+ * - Async API (non-blocking)
+ * - Supports storing large objects like Merkle trees
+ * - Transactional (data integrity)
+ */
+
+/**
+ * Create an IndexedDB storage adapter
+ *
+ * @param prefix - Optional prefix for keys (useful for multi-account)
+ * @returns StorageAdapter instance
+ *
+ * @example
+ * ```ts
+ * const storage = createIndexedDBAdapter('account_0x123')
+ * await storage.set('notes', myNotes)
+ * const notes = await storage.get('notes')
+ * ```
+ */
+declare function createIndexedDBAdapter(prefix?: string): StorageAdapter;
+/**
+ * Default IndexedDB adapter instance (no prefix)
+ */
+declare const indexedDBAdapter: StorageAdapter;
+
+/**
+ * localStorage Storage Adapter
+ *
+ * Provides persistent storage using localStorage for browser environments.
+ * This is a fallback adapter when IndexedDB is not available or for simpler use cases.
+ *
+ * Limitations:
+ * - 5MB storage limit per origin
+ * - Synchronous API (blocks main thread on large operations)
+ * - Data must be JSON serializable
+ */
+
+/**
+ * Create a localStorage storage adapter
+ *
+ * @param prefix - Optional prefix for keys (useful for multi-account)
+ * @returns StorageAdapter instance
+ *
+ * @example
+ * ```ts
+ * const storage = createLocalStorageAdapter('account_0x123')
+ * await storage.set('notes', myNotes)
+ * const notes = await storage.get('notes')
+ * ```
+ */
+declare function createLocalStorageAdapter(prefix?: string): StorageAdapter;
+/**
+ * Default localStorage adapter instance (no prefix)
+ */
+declare const localStorageAdapter: StorageAdapter;
+
+/**
+ * In-Memory Storage Adapter
+ *
+ * Provides non-persistent storage for testing and development.
+ * Data is lost when the process ends or the adapter is cleared.
+ *
+ * Use cases:
+ * - Unit tests
+ * - Server-side rendering (where IndexedDB/localStorage aren't available)
+ * - Development without persistence
+ */
+
+/**
+ * Create an in-memory storage adapter
+ *
+ * @param prefix - Optional prefix for keys
+ * @returns StorageAdapter instance
+ *
+ * @example
+ * ```ts
+ * const storage = createMemoryAdapter()
+ * await storage.set('notes', myNotes)
+ * const notes = await storage.get('notes')
+ * ```
+ */
+declare function createMemoryAdapter(prefix?: string): StorageAdapter & {
+    size(): number;
+    keys(): string[];
+};
+/**
+ * Default in-memory adapter instance (no prefix)
+ */
+declare const memoryAdapter: StorageAdapter & {
+    size(): number;
+    keys(): string[];
+};
+
+/**
+ * Create the best available storage adapter
+ *
+ * Tries IndexedDB first, falls back to localStorage, then memory.
+ *
+ * @param prefix - Optional prefix for keys
+ * @returns The best available StorageAdapter
+ */
+declare function createAutoAdapter(prefix?: string): StorageAdapter;
+
+export { type DecryptedNote, type DecryptionKeys, StorageAdapter, type UnpackedNoteData, computeSearchTag, createAutoAdapter, createIndexedDBAdapter, createLocalStorageAdapter, createMemoryAdapter, indexedDBAdapter, localStorageAdapter, matchesSearchTag, memoryAdapter, tryDecryptNote, unpackNoteData };

package/dist/indexer/index.d.ts

@@ -0,0 +1,206 @@
+import { S as StorageAdapter } from '../index-BBzvvrhG.js';
+export { C as CommitmentInsertedArgs, a as IndexedNote, I as Indexer, f as IndexerState, L as LiveSyncConfig, b as NoteFilters, N as NoteStatus, j as NullifiedArgs, R as RpcIndexerConfig, h as SerializedNote, i as StealthTransactArgs, e as SyncConfig, d as SyncProgress, c as SyncResult, g as SyncState } from '../index-BBzvvrhG.js';
+import { _ as ___index_js } from '../index-ChGaGPzP.js';
+export { m as makeRpcIndexer } from '../index-ChGaGPzP.js';
+import { Hex } from 'viem';
+import { P as Point } from '../merkle-mteVOlDf.js';
+import '../transfer-BlmbO-Rd.js';
+import '../keccak-m31-B_AqBbRF.js';
+import '@permissionless-technologies/upc-sdk';
+import 'react/jsx-runtime';
+import 'react';
+import '../types-mLybMxNR.js';
+import '../keys/index.js';
+import '../utils/index.js';
+
+interface DecryptedNote {
+    amount: bigint;
+    blinding: bigint;
+    oneTimeSecret: bigint;
+    oneTimePubkey: Point;
+    origin: bigint;
+    token: bigint;
+}
+interface UnpackedNoteData {
+    searchTag: bigint;
+    ephemeralPubkeyX: bigint;
+    ephemeralPubkeyY: bigint;
+    encryptedNote: Hex;
+}
+interface DecryptionKeys {
+    spendingSecret: bigint;
+    spendingPubkey: Point;
+    masterViewingSecret: bigint;
+    masterViewingPubKey: Point;
+}
+type SDK = typeof ___index_js;
+/**
+ * Compute the expected search tag for a given ephemeral public key
+ *
+ * The search tag is computed as: Poseidon(viewingSharedSecret.x, 0) & ((1n << 64n) - 1n)
+ * This must match how search tags are computed during note creation in createUPPNote().
+ *
+ * - DVK is the derived viewing key (derived from master viewing key using R.x as nonce)
+ * - R is the ephemeral public key
+ * - viewingSharedSecret = DVK * R
+ *
+ * This allows quick filtering of events before expensive trial decryption.
+ */
+declare function computeSearchTag(sdk: SDK, masterViewingSecret: bigint, masterViewingPubKey: Point, ephemeralPubkey: Point, debug?: boolean): Promise<bigint>;
+/**
+ * Check if a search tag from an event matches our viewing key
+ *
+ * This is a fast check that can filter out 99%+ of events before
+ * attempting expensive trial decryption.
+ *
+ * @param eventSearchTag - The search tag from the event (8 bytes as bigint)
+ * @param sdk - The loaded SDK module
+ * @param masterViewingSecret - Our master viewing secret
+ * @param masterViewingPubKey - Our master viewing public key
+ * @param ephemeralPubkey - The ephemeral public key from the event
+ * @param debug - Enable debug logging
+ * @returns true if the search tag matches (event might be ours)
+ */
+declare function matchesSearchTag(eventSearchTag: bigint, sdk: SDK, masterViewingSecret: bigint, masterViewingPubKey: Point, ephemeralPubkey: Point, debug?: boolean): Promise<boolean>;
+/**
+ * Try to decrypt a note using dual ECDH (UPP format with origin and token)
+ *
+ * 1. Viewing ECDH: DVK * R → AES decryption key (viewing shared secret)
+ * 2. Spending ECDH: spendingSecret * R → one-time key for commitment verification
+ *
+ * DVK is derived using R.x (ephemeral public key x-coordinate) as the nonce.
+ *
+ * UPP encrypted payload: amount (32) + blinding (32) + origin (20) + token (20) = 104 bytes
+ * UPP commitment: Poseidon(amount, pubkeyX, pubkeyY, blinding, origin, token)
+ *
+ * @param sdk - The loaded SDK module
+ * @param keys - Decryption keys (spending and viewing)
+ * @param ephemeralPubkey - The ephemeral public key from the event
+ * @param encryptedNote - The encrypted note data
+ * @param expectedCommitment - The commitment to verify against
+ * @param debug - Enable debug logging
+ * @returns Decrypted note data or null if decryption/verification failed
+ */
+declare function tryDecryptNote(sdk: SDK, keys: DecryptionKeys, ephemeralPubkey: Point, encryptedNote: Hex, expectedCommitment: bigint, debug?: boolean): Promise<DecryptedNote | null>;
+/**
+ * Unpack note data from packed on-chain format
+ *
+ * Format: searchTag (8 bytes) + ephemeralPubkeyX (32 bytes) + ephemeralPubkeyY (32 bytes) + encryptedNote (variable)
+ *
+ * @param packed - The packed note data from the event
+ * @param debug - Enable debug logging
+ * @returns Unpacked note data or null if format is invalid
+ */
+declare function unpackNoteData(packed: Hex, debug?: boolean): UnpackedNoteData | null;
+
+/**
+ * IndexedDB Storage Adapter
+ *
+ * Provides persistent storage using IndexedDB for browser environments.
+ * This is the default and recommended storage adapter for production use.
+ *
+ * Benefits:
+ * - Large capacity (no 5MB limit like localStorage)
+ * - Async API (non-blocking)
+ * - Supports storing large objects like Merkle trees
+ * - Transactional (data integrity)
+ */
+
+/**
+ * Create an IndexedDB storage adapter
+ *
+ * @param prefix - Optional prefix for keys (useful for multi-account)
+ * @returns StorageAdapter instance
+ *
+ * @example
+ * ```ts
+ * const storage = createIndexedDBAdapter('account_0x123')
+ * await storage.set('notes', myNotes)
+ * const notes = await storage.get('notes')
+ * ```
+ */
+declare function createIndexedDBAdapter(prefix?: string): StorageAdapter;
+/**
+ * Default IndexedDB adapter instance (no prefix)
+ */
+declare const indexedDBAdapter: StorageAdapter;
+
+/**
+ * localStorage Storage Adapter
+ *
+ * Provides persistent storage using localStorage for browser environments.
+ * This is a fallback adapter when IndexedDB is not available or for simpler use cases.
+ *
+ * Limitations:
+ * - 5MB storage limit per origin
+ * - Synchronous API (blocks main thread on large operations)
+ * - Data must be JSON serializable
+ */
+
+/**
+ * Create a localStorage storage adapter
+ *
+ * @param prefix - Optional prefix for keys (useful for multi-account)
+ * @returns StorageAdapter instance
+ *
+ * @example
+ * ```ts
+ * const storage = createLocalStorageAdapter('account_0x123')
+ * await storage.set('notes', myNotes)
+ * const notes = await storage.get('notes')
+ * ```
+ */
+declare function createLocalStorageAdapter(prefix?: string): StorageAdapter;
+/**
+ * Default localStorage adapter instance (no prefix)
+ */
+declare const localStorageAdapter: StorageAdapter;
+
+/**
+ * In-Memory Storage Adapter
+ *
+ * Provides non-persistent storage for testing and development.
+ * Data is lost when the process ends or the adapter is cleared.
+ *
+ * Use cases:
+ * - Unit tests
+ * - Server-side rendering (where IndexedDB/localStorage aren't available)
+ * - Development without persistence
+ */
+
+/**
+ * Create an in-memory storage adapter
+ *
+ * @param prefix - Optional prefix for keys
+ * @returns StorageAdapter instance
+ *
+ * @example
+ * ```ts
+ * const storage = createMemoryAdapter()
+ * await storage.set('notes', myNotes)
+ * const notes = await storage.get('notes')
+ * ```
+ */
+declare function createMemoryAdapter(prefix?: string): StorageAdapter & {
+    size(): number;
+    keys(): string[];
+};
+/**
+ * Default in-memory adapter instance (no prefix)
+ */
+declare const memoryAdapter: StorageAdapter & {
+    size(): number;
+    keys(): string[];
+};
+
+/**
+ * Create the best available storage adapter
+ *
+ * Tries IndexedDB first, falls back to localStorage, then memory.
+ *
+ * @param prefix - Optional prefix for keys
+ * @returns The best available StorageAdapter
+ */
+declare function createAutoAdapter(prefix?: string): StorageAdapter;
+
+export { type DecryptedNote, type DecryptionKeys, StorageAdapter, type UnpackedNoteData, computeSearchTag, createAutoAdapter, createIndexedDBAdapter, createLocalStorageAdapter, createMemoryAdapter, indexedDBAdapter, localStorageAdapter, matchesSearchTag, memoryAdapter, tryDecryptNote, unpackNoteData };

package/dist/indexer/index.js

@@ -0,0 +1,5 @@
+export { computeSearchTag, makeRpcIndexer, matchesSearchTag, tryDecryptNote, unpackNoteData } from '../chunk-OQDSHMXU.js';
+export { createAutoAdapter, createIndexedDBAdapter, createLocalStorageAdapter, createMemoryAdapter, indexedDBAdapter, localStorageAdapter, memoryAdapter } from '../chunk-XV72HNHN.js';
+import '../chunk-Z6ZWNWWR.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/indexer/index.js.map

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

package/dist/keccak-m31-B_AqBbRF.d.cts

@@ -0,0 +1,70 @@
+/**
+ * Keccak-256 hashing over M31 field elements.
+ *
+ * This module implements the same hashing algorithm as the Rust Stwo prover
+ * (stwo-prover/src/hash.rs), producing identical outputs for identical inputs.
+ *
+ * Algorithm:
+ * 1. Each M31 element is encoded as 4 little-endian bytes
+ * 2. All encoded bytes are concatenated and fed to Keccak-256
+ * 3. The 32-byte output is split into 4 chunks of 8 bytes
+ * 4. Each chunk is read as a little-endian uint64 and reduced mod M31_P
+ *
+ * M31 field: p = 2^31 - 1 = 2,147,483,647
+ */
+/** The M31 prime: 2^31 - 1 */
+declare const M31_P = 2147483647n;
+/** Number of M31 elements in a digest */
+declare const DIGEST_SIZE = 4;
+/** Number of M31 limbs for owner secrets (248 bits of entropy) */
+declare const SECRET_LIMBS = 8;
+/** M31 digest type: tuple of 4 M31 values */
+type M31Digest = readonly [bigint, bigint, bigint, bigint];
+/** M31 secret type: tuple of 8 M31 values */
+type M31Secret = readonly [bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint];
+/**
+ * Hash arbitrary M31 elements using Keccak-256.
+ *
+ * Matches Rust: `hash_m31(inputs: &[M31]) -> [M31; 4]`
+ *
+ * Each M31 is encoded as 4 little-endian bytes. The keccak output
+ * is split into 4 × 8-byte LE chunks, each reduced mod M31_P.
+ */
+declare function keccakM31(inputs: readonly bigint[]): M31Digest;
+/**
+ * Hash two M31 elements (Merkle tree node hash).
+ *
+ * Matches Rust: `hash_two(left: M31, right: M31) -> [M31; 4]`
+ */
+declare function keccakHashTwo(left: bigint, right: bigint): M31Digest;
+/**
+ * Compute owner hash from an 8-limb secret.
+ *
+ * Matches Rust: `compute_owner_hash(owner_secret: &[M31; 8]) -> [M31; 4]`
+ */
+declare function computeStarkOwnerHash(ownerSecret: M31Secret): M31Digest;
+/**
+ * Compute a STARK note commitment.
+ *
+ * Matches Rust: `compute_commitment(amount, owner_hash, blinding, origin, token)`
+ *
+ * Input order: [amount, ownerHash[0], ownerHash[1], ownerHash[2], ownerHash[3], blinding, origin, token]
+ */
+declare function computeStarkCommitment(amount: bigint, ownerHash: M31Digest, blinding: bigint, origin: bigint, token: bigint): M31Digest;
+/**
+ * Compute a STARK nullifier.
+ *
+ * Matches Rust: `compute_nullifier(owner_secret, leaf_index, commitment)`
+ *
+ * Input order: [ownerSecret[0..8], leafIndex, commitment[0..4]]
+ */
+declare function computeStarkNullifier(ownerSecret: M31Secret, leafIndex: bigint, commitment: M31Digest): M31Digest;
+/**
+ * Split a 32-byte keccak hash into 8 M31 limbs.
+ *
+ * Used for deriving STARK spending/viewing secrets from a seed.
+ * Each limb is 4 bytes of the hash, read as LE uint32, reduced mod M31_P.
+ */
+declare function splitToM31Limbs(hashHex: `0x${string}`): M31Secret;
+
+export { DIGEST_SIZE as D, type M31Secret as M, SECRET_LIMBS as S, type M31Digest as a, M31_P as b, computeStarkCommitment as c, computeStarkNullifier as d, computeStarkOwnerHash as e, keccakM31 as f, keccakHashTwo as k, splitToM31Limbs as s };

package/dist/keccak-m31-B_AqBbRF.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Keccak-256 hashing over M31 field elements.
+ *
+ * This module implements the same hashing algorithm as the Rust Stwo prover
+ * (stwo-prover/src/hash.rs), producing identical outputs for identical inputs.
+ *
+ * Algorithm:
+ * 1. Each M31 element is encoded as 4 little-endian bytes
+ * 2. All encoded bytes are concatenated and fed to Keccak-256
+ * 3. The 32-byte output is split into 4 chunks of 8 bytes
+ * 4. Each chunk is read as a little-endian uint64 and reduced mod M31_P
+ *
+ * M31 field: p = 2^31 - 1 = 2,147,483,647
+ */
+/** The M31 prime: 2^31 - 1 */
+declare const M31_P = 2147483647n;
+/** Number of M31 elements in a digest */
+declare const DIGEST_SIZE = 4;
+/** Number of M31 limbs for owner secrets (248 bits of entropy) */
+declare const SECRET_LIMBS = 8;
+/** M31 digest type: tuple of 4 M31 values */
+type M31Digest = readonly [bigint, bigint, bigint, bigint];
+/** M31 secret type: tuple of 8 M31 values */
+type M31Secret = readonly [bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint];
+/**
+ * Hash arbitrary M31 elements using Keccak-256.
+ *
+ * Matches Rust: `hash_m31(inputs: &[M31]) -> [M31; 4]`
+ *
+ * Each M31 is encoded as 4 little-endian bytes. The keccak output
+ * is split into 4 × 8-byte LE chunks, each reduced mod M31_P.
+ */
+declare function keccakM31(inputs: readonly bigint[]): M31Digest;
+/**
+ * Hash two M31 elements (Merkle tree node hash).
+ *
+ * Matches Rust: `hash_two(left: M31, right: M31) -> [M31; 4]`
+ */
+declare function keccakHashTwo(left: bigint, right: bigint): M31Digest;
+/**
+ * Compute owner hash from an 8-limb secret.
+ *
+ * Matches Rust: `compute_owner_hash(owner_secret: &[M31; 8]) -> [M31; 4]`
+ */
+declare function computeStarkOwnerHash(ownerSecret: M31Secret): M31Digest;
+/**
+ * Compute a STARK note commitment.
+ *
+ * Matches Rust: `compute_commitment(amount, owner_hash, blinding, origin, token)`
+ *
+ * Input order: [amount, ownerHash[0], ownerHash[1], ownerHash[2], ownerHash[3], blinding, origin, token]
+ */
+declare function computeStarkCommitment(amount: bigint, ownerHash: M31Digest, blinding: bigint, origin: bigint, token: bigint): M31Digest;
+/**
+ * Compute a STARK nullifier.
+ *
+ * Matches Rust: `compute_nullifier(owner_secret, leaf_index, commitment)`
+ *
+ * Input order: [ownerSecret[0..8], leafIndex, commitment[0..4]]
+ */
+declare function computeStarkNullifier(ownerSecret: M31Secret, leafIndex: bigint, commitment: M31Digest): M31Digest;
+/**
+ * Split a 32-byte keccak hash into 8 M31 limbs.
+ *
+ * Used for deriving STARK spending/viewing secrets from a seed.
+ * Each limb is 4 bytes of the hash, read as LE uint32, reduced mod M31_P.
+ */
+declare function splitToM31Limbs(hashHex: `0x${string}`): M31Secret;
+
+export { DIGEST_SIZE as D, type M31Secret as M, SECRET_LIMBS as S, type M31Digest as a, M31_P as b, computeStarkCommitment as c, computeStarkNullifier as d, computeStarkOwnerHash as e, keccakM31 as f, keccakHashTwo as k, splitToM31Limbs as s };

package/dist/keys/index.cjs

@@ -0,0 +1,68 @@
+'use strict';
+
+var chunkZKZV6OI3_cjs = require('../chunk-ZKZV6OI3.cjs');
+require('../chunk-BH24DZ5S.cjs');
+require('../chunk-3HQ7A6ZM.cjs');
+require('../chunk-JWNXBALH.cjs');
+require('../chunk-G7VZBCD6.cjs');
+
+
+
+Object.defineProperty(exports, "DEFAULT_KEY_DERIVATION_CONFIG", {
+  enumerable: true,
+  get: function () { return chunkZKZV6OI3_cjs.DEFAULT_KEY_DERIVATION_CONFIG; }
+});
+Object.defineProperty(exports, "deriveDualKeysFromSignature", {
+  enumerable: true,
+  get: function () { return chunkZKZV6OI3_cjs.deriveDualKeysFromSignature; }
+});
+Object.defineProperty(exports, "deriveKeysFromSignature", {
+  enumerable: true,
+  get: function () { return chunkZKZV6OI3_cjs.deriveKeysFromSignature; }
+});
+Object.defineProperty(exports, "deriveNullifierKey", {
+  enumerable: true,
+  get: function () { return chunkZKZV6OI3_cjs.deriveNullifierKey; }
+});
+Object.defineProperty(exports, "derivePerNoteKey", {
+  enumerable: true,
+  get: function () { return chunkZKZV6OI3_cjs.derivePerNoteKey; }
+});
+Object.defineProperty(exports, "derivePerNoteKeyFromKeys", {
+  enumerable: true,
+  get: function () { return chunkZKZV6OI3_cjs.derivePerNoteKeyFromKeys; }
+});
+Object.defineProperty(exports, "deriveStarkKeysFromSignature", {
+  enumerable: true,
+  get: function () { return chunkZKZV6OI3_cjs.deriveStarkKeysFromSignature; }
+});
+Object.defineProperty(exports, "deriveStarkPerNoteKey", {
+  enumerable: true,
+  get: function () { return chunkZKZV6OI3_cjs.deriveStarkPerNoteKey; }
+});
+Object.defineProperty(exports, "deriveStarkPerNoteKeyFromKeys", {
+  enumerable: true,
+  get: function () { return chunkZKZV6OI3_cjs.deriveStarkPerNoteKeyFromKeys; }
+});
+Object.defineProperty(exports, "exportViewingKeysForAudit", {
+  enumerable: true,
+  get: function () { return chunkZKZV6OI3_cjs.exportViewingKeysForAudit; }
+});
+Object.defineProperty(exports, "getKeyDerivationMessage", {
+  enumerable: true,
+  get: function () { return chunkZKZV6OI3_cjs.getKeyDerivationMessage; }
+});
+Object.defineProperty(exports, "getViewingKeyFromExport", {
+  enumerable: true,
+  get: function () { return chunkZKZV6OI3_cjs.getViewingKeyFromExport; }
+});
+Object.defineProperty(exports, "validateAuditKeyExport", {
+  enumerable: true,
+  get: function () { return chunkZKZV6OI3_cjs.validateAuditKeyExport; }
+});
+Object.defineProperty(exports, "verifyKeysMatchSignature", {
+  enumerable: true,
+  get: function () { return chunkZKZV6OI3_cjs.verifyKeysMatchSignature; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/keys/index.cjs.map

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