@unlink-xyz/core 0.1.3-canary.fd5dddf → 0.1.4

package/dist/transactions/transfer-planner.js

@@ -1,85 +0,0 @@
-import { ValidationError } from "../errors.js";
-import { planTransaction } from "./transaction-planner.js";
-/**
- * Plan transfer transaction(s).
- * Accepts 1 or more transfers. When multiple transfers use the same token,
- * notes are tracked across transfers to avoid double-spending.
- *
- * @param notes - Available unspent notes (all tokens)
- * @param transfers - Transfers to plan (each with token, amount, recipientMpk)
- * @param senderMpk - Sender's master public key (for change outputs)
- * @returns Array of transaction plans, one per transfer input
- *
- * @example
- * ```typescript
- * // Single transfer
- * const [plan] = planTransfers(notes, [{ token, amount: 100n, recipientMpk }], senderMpk);
- *
- * // Multiple transfers (possibly same token)
- * const plans = planTransfers(notes, [
- *   { token: ETH, amount: 100n, recipientMpk: recipient1Mpk },
- *   { token: USDC, amount: 50n, recipientMpk: recipient2Mpk },
- * ], senderMpk);
- * ```
- */
-export function planTransfers(notes, transfers, senderMpk) {
-    if (!transfers.length) {
-        throw new ValidationError("At least one transfer is required");
-    }
-    // Validate all transfers upfront
-    for (const t of transfers) {
-        if (!t.token) {
-            throw new ValidationError(`Missing token address in transfer: ${JSON.stringify(t)}`);
-        }
-        // Convert amount to bigint if needed (handles string amounts from frontend)
-        const amount = typeof t.amount === "bigint" ? t.amount : BigInt(t.amount);
-        if (amount <= 0n) {
-            throw new ValidationError(`Invalid transfer amount for ${t.token}: ${t.amount}`);
-        }
-        // Update amount to bigint for downstream use
-        t.amount = amount;
-    }
-    // Pre-validate total balances per token (use normalized tokens for comparison)
-    const requiredByToken = new Map();
-    for (const t of transfers) {
-        const tokenLower = t.token.toLowerCase();
-        const existing = requiredByToken.get(tokenLower) ?? 0n;
-        requiredByToken.set(tokenLower, existing + t.amount);
-    }
-    for (const [tokenLower, required] of requiredByToken) {
-        const available = notes
-            .filter((n) => {
-            const noteToken = n.token;
-            return noteToken && noteToken.toLowerCase() === tokenLower;
-        })
-            .reduce((sum, n) => sum + BigInt(n.value), 0n);
-        if (available < required) {
-            throw new ValidationError(`Insufficient balance for ${tokenLower}: need ${required}, have ${available}`);
-        }
-    }
-    // Track used note indices per token to avoid double-spending
-    const usedNotesByToken = new Map();
-    const plans = [];
-    for (const t of transfers) {
-        const tokenLower = t.token.toLowerCase();
-        // Get available notes for this token, excluding already-used ones
-        const usedIndices = usedNotesByToken.get(tokenLower) ?? new Set();
-        const availableNotes = notes.filter((n) => {
-            const noteToken = n.token;
-            return (noteToken &&
-                noteToken.toLowerCase() === tokenLower &&
-                !usedIndices.has(n.index));
-        });
-        // Plan this transfer using the existing planTransaction function
-        const plan = planTransaction(availableNotes, [{ mpk: t.recipientMpk, amount: t.amount }], senderMpk, t.token);
-        // Mark selected notes as used
-        if (!usedNotesByToken.has(tokenLower)) {
-            usedNotesByToken.set(tokenLower, new Set());
-        }
-        for (const input of plan.inputs) {
-            usedNotesByToken.get(tokenLower).add(input.index);
-        }
-        plans.push(plan);
-    }
-    return plans;
-}

package/dist/transactions/types/deposit.js

@@ -1 +0,0 @@
-export {};

package/dist/transactions/types/domain.js

@@ -1,4 +0,0 @@
-/**
- * Core domain types for cryptographic operations.
- */
-export {};

package/dist/transactions/types/index.js

@@ -1,17 +0,0 @@
-/**
- * Transaction type definitions.
- *
- * Organized by concern:
- * - state-stores: Database/storage interfaces
- * - options: Configuration for services
- * - domain: Core cryptographic types
- * - deposit: Deposit-specific types
- * - transact: Transaction-specific types
- * - planning: Transaction planning types
- */
-export * from "./state-stores.js";
-export * from "./options.js";
-export * from "./domain.js";
-export * from "./deposit.js";
-export * from "./transact.js";
-export * from "./planning.js";

package/dist/transactions/types/options.js

@@ -1 +0,0 @@
-export {};

package/dist/transactions/types/planning.js

@@ -1 +0,0 @@
-export {};

package/dist/transactions/types/state-stores.js

@@ -1 +0,0 @@
-export {};

package/dist/transactions/types/transact.js

@@ -1 +0,0 @@
-export {};

package/dist/transactions/withdrawal-planner.js

@@ -1,128 +0,0 @@
-import { ProofError, ValidationError } from "../errors.js";
-import { CIRCUIT_REGISTRY } from "../prover/registry.js";
-import { randomBigint } from "../utils/random.js";
-import { selectNotesForAmount } from "./note-selection.js";
-/**
- * Select the smallest circuit that fits the given input/output counts.
- * For withdrawals, outputs = change only (0 or 1).
- */
-function selectCircuitForWithdrawal(inputCount, outputCount) {
-    // Sort circuits by total size (inputs + outputs) ascending
-    const circuits = Object.values(CIRCUIT_REGISTRY).sort((a, b) => a.inputs + a.outputs - (b.inputs + b.outputs));
-    const circuit = circuits.find((c) => c.inputs >= inputCount && c.outputs >= outputCount);
-    if (!circuit) {
-        throw new ProofError(`No circuit supports ${inputCount} inputs and ${outputCount} outputs. ` +
-            `Available: ${circuits.map((c) => `${c.inputs}x${c.outputs}`).join(", ")}`);
-    }
-    return circuit;
-}
-/**
- * Plan a single withdrawal transaction. Used internally by `planWithdrawals`.
- */
-function planSingleWithdrawal(notes, withdrawAmount, recipientAddress, senderMpk, token) {
-    if (withdrawAmount <= 0n) {
-        throw new ValidationError("Withdrawal amount must be positive");
-    }
-    const selection = selectNotesForAmount(notes, withdrawAmount, {
-        recipientCount: 0,
-    });
-    const { selected: inputs, totalInput, change } = selection;
-    const changeOutputCount = change > 0n ? 1 : 0;
-    const outputCount = changeOutputCount + 1;
-    const circuit = selectCircuitForWithdrawal(inputs.length, outputCount);
-    const outputNotes = [];
-    if (change > 0n) {
-        const random = randomBigint();
-        outputNotes.push({
-            mpk: senderMpk,
-            random,
-            token,
-            amount: change,
-        });
-    }
-    const withdrawal = {
-        npk: BigInt(recipientAddress),
-        amount: withdrawAmount,
-        token,
-    };
-    return {
-        inputs,
-        outputNotes,
-        withdrawal,
-        circuit,
-        totalInput,
-        withdrawAmount,
-        change,
-        token,
-    };
-}
-/**
- * Plan withdrawal transaction(s).
- * Accepts 1 or more withdrawals. When multiple withdrawals use the same token,
- * notes are tracked across withdrawals to avoid double-spending.
- *
- * @param notes - Available unspent notes (all tokens)
- * @param withdrawals - Withdrawals to plan (each with token, amount, recipient)
- * @param senderMpk - Sender's master public key (for change outputs)
- * @returns Array of withdrawal plans, one per withdrawal input
- *
- * @example
- * ```typescript
- * // Single withdrawal
- * const [plan] = planWithdrawals(notes, [{ token, amount: 100n, recipient: "0x..." }], mpk);
- *
- * // Multiple withdrawals (possibly same token)
- * const plans = planWithdrawals(notes, [
- *   { token: ETH, amount: 100n, recipient: "0x..." },
- *   { token: USDC, amount: 50n, recipient: "0x..." },
- * ], mpk);
- * ```
- */
-export function planWithdrawals(notes, withdrawals, senderMpk) {
-    if (!withdrawals.length) {
-        throw new ValidationError("At least one withdrawal is required");
-    }
-    // Validate all withdrawals upfront
-    for (const w of withdrawals) {
-        if (w.amount <= 0n) {
-            throw new ValidationError(`Invalid withdrawal amount for ${w.token}: ${w.amount}`);
-        }
-    }
-    // Pre-validate total balances per token (use normalized tokens for comparison)
-    const requiredByToken = new Map();
-    for (const w of withdrawals) {
-        const tokenLower = w.token.toLowerCase();
-        const existing = requiredByToken.get(tokenLower) ?? 0n;
-        requiredByToken.set(tokenLower, existing + w.amount);
-    }
-    for (const [tokenLower, required] of requiredByToken) {
-        const available = notes
-            .filter((n) => n.token.toLowerCase() ===
-            tokenLower)
-            .reduce((sum, n) => sum + BigInt(n.value), 0n);
-        if (available < required) {
-            throw new ValidationError(`Insufficient balance for ${tokenLower}: need ${required}, have ${available}`);
-        }
-    }
-    // Track used note indices per token to avoid double-spending
-    const usedNotesByToken = new Map();
-    const plans = [];
-    for (const w of withdrawals) {
-        const tokenLower = w.token.toLowerCase();
-        // Get available notes for this token, excluding already-used ones
-        const usedIndices = usedNotesByToken.get(tokenLower) ?? new Set();
-        const availableNotes = notes.filter((n) => n.token.toLowerCase() ===
-            tokenLower && !usedIndices.has(n.index));
-        // Plan this withdrawal (pass original token for output)
-        const plan = planSingleWithdrawal(availableNotes, w.amount, w.recipient, senderMpk, w.token);
-        // Mark selected notes as used
-        if (!usedNotesByToken.has(tokenLower)) {
-            usedNotesByToken.set(tokenLower, new Set());
-        }
-        for (const input of plan.inputs) {
-            usedNotesByToken.get(tokenLower).add(input.index);
-        }
-        plans.push(plan);
-    }
-    return plans;
-}

package/dist/tsup.browser.config.js

@@ -1,34 +0,0 @@
-import { NodeGlobalsPolyfillPlugin } from "@esbuild-plugins/node-globals-polyfill";
-import { NodeModulesPolyfillPlugin } from "@esbuild-plugins/node-modules-polyfill";
-import { defineConfig } from "tsup";
-/**
- * Browser build configuration.
- * Bundles all dependencies with Node.js polyfills for browser compatibility.
- */
-export default defineConfig({
-    entry: ["index.ts"],
-    format: ["esm"],
-    dts: false, // Types are generated by the main tsc build
-    clean: false, // Don't clean dist/ to preserve tsc output
-    splitting: false,
-    sourcemap: true,
-    minify: false,
-    // Bundle everything including dependencies for browser compatibility
-    noExternal: [/.*/],
-    esbuildPlugins: [
-        NodeModulesPolyfillPlugin(),
-        NodeGlobalsPolyfillPlugin({
-            buffer: true,
-            process: true,
-        }),
-    ],
-    esbuildOptions(options) {
-        options.supported = {
-            ...options.supported,
-            "top-level-await": true,
-        };
-    },
-    platform: "browser",
-    target: "es2022",
-    outDir: "dist/browser",
-});

package/dist/types.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/amounts.js

@@ -1,89 +0,0 @@
-import { ValidationError } from "../errors.js";
-/**
- * Parse a decimal string to bigint with specified decimals.
- *
- * @param value - Decimal string (e.g., "10.5", "42")
- * @param decimals - Number of decimal
- * @returns Amount as bigint in atomic units
- * @throws ValidationError if value is invalid or has too many decimal places
- *
- * @example
- * parseAmount("10.5", 18) // Returns 10500000000000000000n
- * parseAmount("0.001", 6) // Returns 1000n
- */
-export function parseAmount(value, decimals) {
-    const trimmed = value.trim();
-    if (!trimmed) {
-        throw new ValidationError("Amount cannot be empty");
-    }
-    if (!/^\d*(\.\d*)?$/.test(trimmed)) {
-        throw new ValidationError("Amount must be numeric and can include decimals (e.g., '10.5')");
-    }
-    const [rawWhole = "0", rawFraction = ""] = trimmed.split(".");
-    const whole = rawWhole === "" ? "0" : rawWhole;
-    if (rawFraction.length > decimals) {
-        throw new ValidationError(`Amount supports up to ${decimals} decimal places; trim the fractional part`);
-    }
-    // Pad fraction to full decimal places
-    const fraction = rawFraction.padEnd(decimals, "0");
-    const combined = `${whole}${fraction}`;
-    // Remove leading zeros
-    const normalized = combined.replace(/^0+(?=\d)/, "");
-    return normalized ? BigInt(normalized) : 0n;
-}
-/**
- * Format a bigint amount to a decimal string.
- *
- * @param amount - Amount in atomic units as bigint
- * @param decimals - Number of decimal places
- * @returns Human-readable decimal string
- *
- * @example
- * formatAmount(10500000000000000000n, 18) // Returns "10.5"
- * formatAmount(1000n, 6) // Returns "0.001"
- */
-export function formatAmount(amount, decimals) {
-    if (amount < 0n) {
-        throw new ValidationError("Amount must be non-negative");
-    }
-    const amountStr = amount.toString().padStart(decimals + 1, "0");
-    const wholePartEnd = amountStr.length - decimals;
-    const wholePart = amountStr.slice(0, wholePartEnd) || "0";
-    const fractionPart = amountStr.slice(wholePartEnd);
-    // Remove trailing zeros from fraction
-    const trimmedFraction = fractionPart.replace(/0+$/, "");
-    return trimmedFraction ? `${wholePart}.${trimmedFraction}` : wholePart;
-}
-/**
- * Split a total amount into N equal parts, distributing remainder evenly.
- *
- * @param total - Total amount to split
- * @param parts - Number of parts to split into
- * @returns Array of amounts that sum to total
- * @throws ValidationError if parts is invalid or amount is too small to split
- *
- * @example
- * splitAmount(100n, 3) // Returns [34n, 33n, 33n] (remainder goes to first outputs)
- * splitAmount(10n, 2) // Returns [5n, 5n]
- */
-export function splitAmount(total, parts) {
-    if (parts === 0) {
-        return [];
-    }
-    if (parts < 0) {
-        throw new ValidationError("Number of parts must be non-negative");
-    }
-    if (!Number.isInteger(parts)) {
-        throw new ValidationError("Number of parts must be an integer");
-    }
-    if (total < BigInt(parts)) {
-        throw new ValidationError(`Amount (${total}) is too small to distribute across ${parts} outputs (minimum 1 per output)`);
-    }
-    const base = total / BigInt(parts);
-    if (base <= 0n) {
-        throw new ValidationError("Output share must be positive");
-    }
-    const remainder = Number(total - base * BigInt(parts));
-    // Distribute remainder across first N outputs
-    return Array.from({ length: parts }, (_, idx) => base + (idx < remainder ? 1n : 0n));
-}

package/dist/utils/bigint.js

@@ -1,29 +0,0 @@
-import { ValidationError } from "../errors.js";
-import { FieldSize, Hex } from "../keys/hex.js";
-/**
- * BigInt helpers shared across transaction builders to keep formatting consistent.
- */
-export function formatUint256(value) {
-    assertNonNegative("uint256", value);
-    return Hex.fromBigInt(value, FieldSize.SCALAR, true);
-}
-export function parseHexToBigInt(value) {
-    return Hex.toBigInt(value);
-}
-export function parseNumToBigInt(value) {
-    if (value === undefined) {
-        throw new ValidationError("Value is undefined");
-    }
-    return BigInt(value);
-}
-export function assertNonNegative(label, value) {
-    if (value < 0n) {
-        throw new ValidationError(`${label} must be non-negative`);
-    }
-}
-export function ensureBigint(label, value) {
-    if (typeof value !== "bigint") {
-        throw new ValidationError(`${label} must be provided as a bigint`);
-    }
-    return value;
-}

package/dist/utils/crypto.d.ts

@@ -1,18 +0,0 @@
-import { Ciphertext, NoteInput } from "../transactions/types/index.js";
-export declare function encryptNote(note: NoteInput): Ciphertext;
-export declare function encrypt(data: bigint, key: bigint): bigint;
-export declare function decryptNote(c: Ciphertext, key: bigint): NoteInput;
-export declare function deriveCommitment(note: {
-    npk: bigint;
-    amount: bigint;
-    token: string;
-}): bigint;
-/**
- * Derive the nullifier public key (npk) from a note.
- */
-export declare function deriveNpk(note: NoteInput): bigint;
-/**
- * Compute the commitment for a note given its npk.
- */
-export declare function computeCommitment(note: NoteInput, npk: bigint): bigint;
-//# sourceMappingURL=crypto.d.ts.map

package/dist/utils/crypto.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../utils/crypto.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAGvE,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,UAAU,CAQvD;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAYjE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,UAGA;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,UAExC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,UAG7D"}

package/dist/utils/crypto.js

@@ -1,45 +0,0 @@
-import { poseidon } from "../crypto-adapters/index.js";
-import { CoreError } from "../errors.js";
-import { parseHexToBigInt } from "./bigint.js";
-export function encryptNote(note) {
-    return {
-        data: [
-            encrypt(note.random, note.mpk),
-            encrypt(parseHexToBigInt(note.token), note.mpk),
-            encrypt(note.amount, note.mpk),
-        ],
-    };
-}
-export function encrypt(data, key) {
-    return poseidon([0x556e6c696e6b, key]) ^ data;
-}
-export function decryptNote(c, key) {
-    const token_bigint = encrypt(c.data[1], key);
-    if (token_bigint > 0xffffffffffffffffffffffffffffffffffffffffn) {
-        throw new CoreError("Invalid Decrypt");
-    }
-    const result = {
-        mpk: key,
-        random: encrypt(c.data[0], key),
-        token: "0x" + token_bigint.toString(16).padStart(40, "0"),
-        amount: encrypt(c.data[2], key),
-    };
-    return result;
-}
-export function deriveCommitment(note) {
-    const tokenScalar = BigInt(note.token);
-    return poseidon([note.npk, tokenScalar, note.amount]);
-}
-/**
- * Derive the nullifier public key (npk) from a note.
- */
-export function deriveNpk(note) {
-    return poseidon([note.mpk, note.random]);
-}
-/**
- * Compute the commitment for a note given its npk.
- */
-export function computeCommitment(note, npk) {
-    const tokenScalar = BigInt(note.token);
-    return poseidon([npk, tokenScalar, note.amount]);
-}

package/dist/utils/format.js

@@ -1,33 +0,0 @@
-import { ensureAddress } from "./validators.js";
-/**
- * Normalize and validate an Ethereum address.
- *
- * @param value - Address string to normalize
- * @returns Normalized lowercase address
- * @throws CoreError if the address is invalid
- *
- * @example
- * normalizeAddress("0xABC123...") // Returns "0xabc123..."
- */
-export function normalizeAddress(value) {
-    return ensureAddress("address", value);
-}
-/**
- * Shorten a hex string for display.
- *
- * @param value - Hex string to shorten
- * @param chars - Number of characters to show at start/end (default: 4)
- * @returns Shortened string like "0x1234…abcd"
- *
- * @example
- * shortenHex("0x1234567890abcdef1234567890abcdef12345678") // "0x1234…5678"
- * shortenHex("0x1234567890abcdef1234567890abcdef12345678", 6) // "0x123456…345678"
- */
-export function shortenHex(value, chars = 4) {
-    if (!value.startsWith("0x") || value.length <= chars * 2 + 2) {
-        return value;
-    }
-    return `${value.slice(0, chars + 2)}…${value.slice(-chars)}`;
-}
-// Re-export random utilities from dedicated module
-export { randomHex, randomBigint } from "./random.js";

package/dist/utils/json-codec.js

@@ -1,25 +0,0 @@
-import { CoreError } from "../errors.js";
-import { validateKey } from "../keys.js";
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-export function encodeJson(value) {
-    return encoder.encode(JSON.stringify(value));
-}
-export function decodeJson(payload) {
-    try {
-        return JSON.parse(decoder.decode(payload));
-    }
-    catch {
-        throw new CoreError("failed to decode stored state payload");
-    }
-}
-export async function putJson(storage, key, record) {
-    validateKey(key);
-    await storage.put(key, encodeJson(record));
-}
-export async function getJson(storage, key) {
-    const payload = await storage.get(key);
-    if (!payload)
-        return null;
-    return decodeJson(payload);
-}

package/dist/utils/notes.js

@@ -1,14 +0,0 @@
-/**
- * Computes token balances from a list of notes.
- *
- * @param notes - Array of notes to compute balances from
- * @returns Record mapping token address to total balance
- */
-export function computeBalances(notes) {
-    const totals = {};
-    for (const note of notes) {
-        const value = typeof note.value === "bigint" ? note.value : BigInt(note.value);
-        totals[note.token] = (totals[note.token] ?? 0n) + value;
-    }
-    return totals;
-}

package/dist/utils/polling.js

@@ -1,11 +0,0 @@
-/**
- * Shared polling configuration constants.
- */
-export const DEFAULT_POLL_INTERVAL_MS = 500;
-export const DEFAULT_POLL_TIMEOUT_MS = 30_000;
-export const MAX_POLL_INTERVAL_MS = 5_000;
-/**
- * Initial delay before first poll for fresh deposits.
- * Reduces wasted 404 requests while commitment is being indexed.
- */
-export const DEFAULT_INITIAL_POLL_DELAY_MS = 2_000;

package/dist/utils/random.js

@@ -1,27 +0,0 @@
-import { CoreError } from "../errors.js";
-/**
- * Generate a cryptographically secure random bigint.
- * @param bytes - Number of bytes of randomness (default: 32 for 256-bit)
- * @returns Random bigint
- */
-export function randomBigint(bytes = 32) {
-    if (typeof globalThis.crypto?.getRandomValues !== "function") {
-        throw new CoreError("crypto.getRandomValues is not available");
-    }
-    const buffer = new Uint8Array(bytes);
-    globalThis.crypto.getRandomValues(buffer);
-    return BigInt("0x" +
-        Array.from(buffer)
-            .map((b) => b.toString(16).padStart(2, "0"))
-            .join(""));
-}
-/**
- * Generate a cryptographically secure random hex string.
- * @param bytes - Number of bytes of randomness
- * @returns Random hex string with 0x prefix
- */
-export function randomHex(bytes) {
-    return `0x${randomBigint(bytes)
-        .toString(16)
-        .padStart(bytes * 2, "0")}`;
-}

package/dist/utils/secure-memory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"secure-memory.d.ts","sourceRoot":"","sources":["../../utils/secure-memory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAI/C"}

package/dist/utils/secure-memory.js

@@ -1,28 +0,0 @@
-/**
- * IMPORTANT limitations:
- * - Garbage collection timing is unpredictable
- * - Strings are immutable
- * - No compiler enforcement to prevent copies
- */
-/**
- * Securely zeros out a Uint8Array's contents by overwriting with zeros.
- * This should be called on all sensitive cryptographic material after use
- *
- * @param bytes - The Uint8Array to zeroize (will be mutated in place)
- *
- * @example
- * ```typescript
- * const privateKey = derivePrivateKey(seed);
- * try {
- *   const signature = sign(message, privateKey);
- *   return signature;
- * } finally {
- *   zeroize(privateKey); // Clear sensitive data
- * }
- * ```
- */
-export function zeroize(bytes) {
-    if (!bytes || bytes.length === 0)
-        return;
-    bytes.fill(0);
-}

package/dist/utils/signature.js

@@ -1,14 +0,0 @@
-import { signMessage } from "../crypto-adapters/index.js";
-/**
- * Generates an EdDSA signature over a poseidon-hashed message using the spending private key.
- * Used for transact public signal signing.
- *
- * The spendingPrivateKey parameter should be zeroized by the caller after use.
- *
- * @param spendingPrivateKey - The 32-byte spending private key (will not be mutated)
- * @param message - The bigint message to sign
- * @returns The EdDSA signature
- */
-export function signTransactMessage(spendingPrivateKey, message) {
-    return signMessage(spendingPrivateKey, message);
-}