@permissionless-technologies/upp-sdk 0.1.0

package/dist/merkle-mteVOlDf.d.ts

@@ -0,0 +1,188 @@
+/**
+ * BabyJubJub Elliptic Curve Utilities
+ *
+ * Wrapper around circomlibjs BabyJubJub implementation.
+ * Used for stealth addresses, key derivation, and ECDH.
+ *
+ * BabyJubJub is a twisted Edwards curve embedded in BN254's scalar field,
+ * making it efficient for use in zk-SNARKs.
+ */
+/**
+ * A point on the BabyJubJub curve
+ */
+interface Point {
+    x: bigint;
+    y: bigint;
+}
+/**
+ * Get the BabyJubJub subgroup order
+ */
+declare function getSubOrder(): Promise<bigint>;
+/**
+ * Get the generator point (Base8)
+ */
+declare function getBasePoint(): Promise<Point>;
+/**
+ * Check if a point is on the curve
+ */
+declare function isOnCurve(point: Point): Promise<boolean>;
+/**
+ * Scalar multiplication: point * scalar
+ *
+ * @param point - Point on the curve
+ * @param scalar - Scalar value (mod subOrder)
+ * @returns Resulting point
+ */
+declare function mulPointScalar(point: Point, scalar: bigint): Promise<Point>;
+/**
+ * Point addition: p1 + p2
+ */
+declare function addPoints(p1: Point, p2: Point): Promise<Point>;
+/**
+ * Generate public key from private key
+ * pubKey = privateKey * Base8
+ *
+ * @param privateKey - Private key scalar (must be < subOrder)
+ * @returns Public key point
+ */
+declare function privateToPublic(privateKey: bigint): Promise<Point>;
+/**
+ * Compute ECDH shared secret
+ * sharedSecret = myPrivateKey * theirPublicKey
+ *
+ * @param myPrivateKey - Your private key
+ * @param theirPublicKey - Their public key
+ * @returns Shared secret point
+ */
+declare function computeSharedSecret(myPrivateKey: bigint, theirPublicKey: Point): Promise<Point>;
+/**
+ * Pack a point into a single bigint (compressed form)
+ * Uses the x-coordinate and a sign bit for y
+ */
+declare function packPoint(point: Point): bigint;
+/**
+ * Convert a point to tuple format [x, y] for use with snarkjs
+ */
+declare function pointToTuple(point: Point): [bigint, bigint];
+/**
+ * Convert a tuple [x, y] to Point format
+ */
+declare function tupleToPoint(tuple: [bigint, bigint]): Point;
+/**
+ * Derive a per-transaction viewing public key (EVK)
+ *
+ * EVK = MVK_pub + Poseidon(MVK_pub.x, MVK_pub.y, nonce) * Base8
+ *
+ * This allows the sender to derive a unique encryption key for each transaction
+ * without knowing the recipient's private key.
+ *
+ * @param masterViewingPubKey - Recipient's master viewing public key
+ * @param nonce - Unique per-note nonce (R.x — ephemeral public key x-coordinate)
+ * @returns Per-transaction encryption viewing key
+ */
+declare function deriveEncryptionViewingKey(masterViewingPubKey: Point, nonce: bigint): Promise<Point>;
+/**
+ * Derive a per-transaction viewing private key (DVK)
+ *
+ * DVK = MVK_priv + Poseidon(MVK_pub.x, MVK_pub.y, nonce)
+ *
+ * Only the owner with MVK_priv can compute this.
+ * DVK can be shared with auditors to decrypt specific transactions.
+ *
+ * @param masterViewingPrivKey - Owner's master viewing private key
+ * @param masterViewingPubKey - Owner's master viewing public key
+ * @param nonce - Unique per-note nonce (R.x — ephemeral public key x-coordinate)
+ * @returns Per-transaction decryption viewing key
+ */
+declare function deriveDecryptionViewingKey(masterViewingPrivKey: bigint, masterViewingPubKey: Point, nonce: bigint): Promise<bigint>;
+
+/**
+ * Merkle Tree Utilities
+ *
+ * Client-side Merkle tree for computing proofs.
+ * Compatible with LeanIMT on-chain implementation.
+ */
+/**
+ * Maximum tree depth (matches contract)
+ */
+declare const MAX_TREE_DEPTH = 32;
+/**
+ * Merkle proof for a leaf
+ */
+interface MerkleProof {
+    /** Path elements (siblings) */
+    pathElements: bigint[];
+    /** Path indices (0 = left, 1 = right) */
+    pathIndices: number[];
+    /** Leaf index in the tree */
+    leafIndex: number;
+    /** Tree root */
+    root: bigint;
+}
+/**
+ * LeanIMT-compatible Merkle Tree
+ *
+ * Features:
+ * - Dynamic depth (grows as needed)
+ * - Single-child optimization
+ * - Async hash operations (Poseidon is async)
+ */
+declare class MerkleTree {
+    private leaves;
+    private nodes;
+    private cachedRoot;
+    readonly maxDepth: number;
+    constructor(maxDepth?: number);
+    /**
+     * Insert a leaf into the tree
+     */
+    insert(leaf: bigint): number;
+    /**
+     * Get the number of leaves in the tree
+     */
+    get size(): number;
+    /**
+     * Get the current depth of the tree
+     * LeanIMT: depth grows when 2^depth < size
+     */
+    get depth(): number;
+    /**
+     * Check if a leaf exists in the tree
+     */
+    has(leaf: bigint): boolean;
+    /**
+     * Get the index of a leaf
+     */
+    indexOf(leaf: bigint): number;
+    /**
+     * Get the current root (async because of Poseidon)
+     */
+    getRoot(): Promise<bigint>;
+    /**
+     * Get a Merkle proof for a leaf at index
+     */
+    getProof(index: number): Promise<MerkleProof>;
+    /**
+     * Get the hash of a node at (level, index)
+     * level 0 = leaves, higher levels are internal nodes
+     */
+    private getNodeHash;
+    /**
+     * Compute the root hash
+     */
+    private computeRoot;
+}
+/**
+ * Build a Merkle tree from an array of leaves
+ */
+declare function buildMerkleTree(leaves: bigint[]): MerkleTree;
+/**
+ * Get a Merkle proof for a specific leaf (async)
+ */
+declare function getMerkleProof(leaves: bigint[], index: number): Promise<MerkleProof>;
+/**
+ * Verify a Merkle proof (async)
+ */
+declare function verifyMerkleProof(leaf: bigint, proof: MerkleProof): Promise<boolean>;
+
+export { MAX_TREE_DEPTH as M, type Point as P, type MerkleProof as a, MerkleTree as b, addPoints as c, buildMerkleTree as d, computeSharedSecret as e, deriveDecryptionViewingKey as f, deriveEncryptionViewingKey as g, getBasePoint as h, getMerkleProof as i, getSubOrder as j, isOnCurve as k, pointToTuple as l, mulPointScalar as m, privateToPublic as n, packPoint as p, tupleToPoint as t, verifyMerkleProof as v };

package/dist/poseidon-UHTJLWQM.js

@@ -0,0 +1,7 @@
+import { init_poseidon } from './chunk-V23OSL25.js';
+export { BABYJUBJUB_SUBORDER, FIELD_PRIME, addressToField, fieldToAddress, isValidFieldElement, poseidon, poseidonHash, poseidonScalar, toFieldElement } from './chunk-V23OSL25.js';
+import './chunk-Z6ZWNWWR.js';
+
+init_poseidon();
+//# sourceMappingURL=poseidon-UHTJLWQM.js.map
+//# sourceMappingURL=poseidon-UHTJLWQM.js.map

package/dist/poseidon-UHTJLWQM.js.map

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

package/dist/poseidon-WHJSZSNP.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var chunkJWNXBALH_cjs = require('./chunk-JWNXBALH.cjs');
+require('./chunk-G7VZBCD6.cjs');
+
+chunkJWNXBALH_cjs.init_poseidon();
+
+Object.defineProperty(exports, "BABYJUBJUB_SUBORDER", {
+  enumerable: true,
+  get: function () { return chunkJWNXBALH_cjs.BABYJUBJUB_SUBORDER; }
+});
+Object.defineProperty(exports, "FIELD_PRIME", {
+  enumerable: true,
+  get: function () { return chunkJWNXBALH_cjs.FIELD_PRIME; }
+});
+Object.defineProperty(exports, "addressToField", {
+  enumerable: true,
+  get: function () { return chunkJWNXBALH_cjs.addressToField; }
+});
+Object.defineProperty(exports, "fieldToAddress", {
+  enumerable: true,
+  get: function () { return chunkJWNXBALH_cjs.fieldToAddress; }
+});
+Object.defineProperty(exports, "isValidFieldElement", {
+  enumerable: true,
+  get: function () { return chunkJWNXBALH_cjs.isValidFieldElement; }
+});
+Object.defineProperty(exports, "poseidon", {
+  enumerable: true,
+  get: function () { return chunkJWNXBALH_cjs.poseidon; }
+});
+Object.defineProperty(exports, "poseidonHash", {
+  enumerable: true,
+  get: function () { return chunkJWNXBALH_cjs.poseidonHash; }
+});
+Object.defineProperty(exports, "poseidonScalar", {
+  enumerable: true,
+  get: function () { return chunkJWNXBALH_cjs.poseidonScalar; }
+});
+Object.defineProperty(exports, "toFieldElement", {
+  enumerable: true,
+  get: function () { return chunkJWNXBALH_cjs.toFieldElement; }
+});
+//# sourceMappingURL=poseidon-WHJSZSNP.cjs.map
+//# sourceMappingURL=poseidon-WHJSZSNP.cjs.map

package/dist/poseidon-WHJSZSNP.cjs.map

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

package/dist/proof-5OECB3RQ.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var chunkSQKBT2SH_cjs = require('./chunk-SQKBT2SH.cjs');
+require('./chunk-G7VZBCD6.cjs');
+
+
+
+Object.defineProperty(exports, "ASP_TREE_DEPTH", {
+  enumerable: true,
+  get: function () { return chunkSQKBT2SH_cjs.ASP_TREE_DEPTH; }
+});
+Object.defineProperty(exports, "STATE_TREE_DEPTH", {
+  enumerable: true,
+  get: function () { return chunkSQKBT2SH_cjs.STATE_TREE_DEPTH; }
+});
+Object.defineProperty(exports, "formatProofForContract", {
+  enumerable: true,
+  get: function () { return chunkSQKBT2SH_cjs.formatProofForContract; }
+});
+Object.defineProperty(exports, "generateProof", {
+  enumerable: true,
+  get: function () { return chunkSQKBT2SH_cjs.generateProof; }
+});
+Object.defineProperty(exports, "generateStealthProof", {
+  enumerable: true,
+  get: function () { return chunkSQKBT2SH_cjs.generateStealthProof; }
+});
+Object.defineProperty(exports, "generateUPPProof", {
+  enumerable: true,
+  get: function () { return chunkSQKBT2SH_cjs.generateUPPProof; }
+});
+Object.defineProperty(exports, "getStealthCircuitArtifacts", {
+  enumerable: true,
+  get: function () { return chunkSQKBT2SH_cjs.getStealthCircuitArtifacts; }
+});
+Object.defineProperty(exports, "getUPPCircuitArtifacts", {
+  enumerable: true,
+  get: function () { return chunkSQKBT2SH_cjs.getUPPCircuitArtifacts; }
+});
+Object.defineProperty(exports, "verifyProof", {
+  enumerable: true,
+  get: function () { return chunkSQKBT2SH_cjs.verifyProof; }
+});
+//# sourceMappingURL=proof-5OECB3RQ.cjs.map
+//# sourceMappingURL=proof-5OECB3RQ.cjs.map

package/dist/proof-5OECB3RQ.cjs.map

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

package/dist/proof-C4YBP6RY.js

@@ -0,0 +1,4 @@
+export { ASP_TREE_DEPTH, STATE_TREE_DEPTH, formatProofForContract, generateProof, generateStealthProof, generateUPPProof, getStealthCircuitArtifacts, getUPPCircuitArtifacts, verifyProof } from './chunk-S4B7GYLN.js';
+import './chunk-Z6ZWNWWR.js';
+//# sourceMappingURL=proof-C4YBP6RY.js.map
+//# sourceMappingURL=proof-C4YBP6RY.js.map

package/dist/proof-C4YBP6RY.js.map

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