@unlink-xyz/core 0.1.3 → 0.1.4

package/dist/account/zkAccount.js

@@ -1,128 +0,0 @@
-import { Mnemonic } from "../key-derivation/bip39.js";
-import { ByteUtils } from "../key-derivation/bytes.js";
-import { deriveNodesFromSeed, WalletNode, } from "../key-derivation/wallet-node.js";
-export const MASTER_SEED_LENGTH = 64;
-export const MASTER_SEED_KEY = "cfg:wallet:master_seed/v1";
-export const MASTER_MNEMONIC_KEY = "cfg:wallet:master_mnemonic/v1";
-const MNEMONIC_ENTROPY_BYTES = 32;
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder();
-export async function deriveZkAccount(masterSeed, accountIndex = 0) {
-    const seed = normalizeMasterSeed(masterSeed);
-    if (!Number.isInteger(accountIndex) || accountIndex < 0) {
-        throw new Error("accountIndex must be a non-negative integer");
-    }
-    const { spending, viewing } = deriveNodesFromSeed(seed, accountIndex);
-    const spendingKeyPair = spending.getSpendingKeyPair();
-    const viewingKeyPair = await viewing.getViewingKeyPair();
-    const nullifyingKey = WalletNode.getNullifyingKey(viewingKeyPair.privateKey);
-    const masterPublicKey = WalletNode.getMasterPublicKey(spendingKeyPair.pubkey, nullifyingKey);
-    return {
-        spendingKeyPair,
-        viewingKeyPair,
-        nullifyingKey,
-        masterPublicKey,
-    };
-}
-export async function deriveZkAccountFromMnemonic(mnemonic, accountIndex = 0, password = "") {
-    const normalized = normalizeMnemonic(mnemonic);
-    const seed = mnemonicToSeed(normalized, password);
-    return deriveZkAccount(seed, accountIndex);
-}
-const identityMasterSeedCrypto = {
-    encrypt(seed) {
-        return clone(seed);
-    },
-    decrypt(payload) {
-        return clone(payload);
-    },
-};
-export async function generateMasterSeed({ storage, rng, crypto = identityMasterSeedCrypto, overwrite = false, mnemonicPassphrase, }) {
-    if (!overwrite) {
-        const existingSeed = await loadMasterSeed(storage, crypto);
-        if (existingSeed)
-            return existingSeed;
-        const existingMnemonic = await loadMasterMnemonic(storage, crypto);
-        if (existingMnemonic) {
-            const seedFromMnemonic = mnemonicToSeed(existingMnemonic, mnemonicPassphrase);
-            await storeMasterSeed(storage, seedFromMnemonic, crypto);
-            return seedFromMnemonic;
-        }
-    }
-    const entropy = rng(MNEMONIC_ENTROPY_BYTES);
-    if (entropy.length !== MNEMONIC_ENTROPY_BYTES) {
-        throw new Error(`mnemonic entropy must be ${MNEMONIC_ENTROPY_BYTES} bytes`);
-    }
-    const mnemonic = Mnemonic.fromEntropy(ByteUtils.bytesToHex(entropy));
-    await storeMasterMnemonic(storage, mnemonic, crypto);
-    const seed = mnemonicToSeed(mnemonic, mnemonicPassphrase);
-    await storeMasterSeed(storage, seed, crypto);
-    return seed;
-}
-export async function loadMasterSeed(storage, crypto = identityMasterSeedCrypto) {
-    const stored = await storage.get(MASTER_SEED_KEY);
-    if (!stored)
-        return null;
-    const plaintext = await crypto.decrypt(stored);
-    return normalizeMasterSeed(plaintext);
-}
-export async function storeMasterSeed(storage, seed, crypto = identityMasterSeedCrypto) {
-    const normalized = normalizeMasterSeed(seed);
-    const encrypted = await crypto.encrypt(normalized);
-    if (!(encrypted instanceof Uint8Array)) {
-        throw new Error("master seed encryptor must return Uint8Array");
-    }
-    await storage.put(MASTER_SEED_KEY, clone(encrypted));
-}
-export async function loadMasterMnemonic(storage, crypto = identityMasterSeedCrypto) {
-    const stored = await storage.get(MASTER_MNEMONIC_KEY);
-    if (!stored)
-        return null;
-    const plaintext = await crypto.decrypt(stored);
-    const mnemonic = textDecoder.decode(plaintext);
-    return normalizeMnemonic(mnemonic);
-}
-export async function importMasterMnemonic({ storage, mnemonic, crypto = identityMasterSeedCrypto, overwrite = false, password = "", }) {
-    if (!overwrite) {
-        const existing = await loadMasterMnemonic(storage, crypto);
-        if (existing) {
-            throw new Error("master mnemonic already exists; set overwrite to true to replace it");
-        }
-    }
-    const normalized = normalizeMnemonic(mnemonic);
-    const seed = mnemonicToSeed(normalized, password);
-    await storeMasterMnemonic(storage, normalized, crypto);
-    await storeMasterSeed(storage, seed, crypto);
-    return seed;
-}
-export async function storeMasterMnemonic(storage, mnemonic, crypto = identityMasterSeedCrypto) {
-    const normalized = normalizeMnemonic(mnemonic);
-    const encrypted = await crypto.encrypt(textEncoder.encode(normalized));
-    if (!(encrypted instanceof Uint8Array)) {
-        throw new Error("master mnemonic encryptor must return Uint8Array");
-    }
-    await storage.put(MASTER_MNEMONIC_KEY, clone(encrypted));
-}
-function clone(bytes) {
-    return new Uint8Array(bytes);
-}
-function normalizeMasterSeed(seed) {
-    if (!(seed instanceof Uint8Array)) {
-        throw new Error("master seed must be a Uint8Array");
-    }
-    if (seed.length !== MASTER_SEED_LENGTH) {
-        throw new Error(`master seed must be ${MASTER_SEED_LENGTH} bytes`);
-    }
-    return clone(seed);
-}
-function normalizeMnemonic(mnemonic) {
-    const formatted = mnemonic.trim().replace(/\s+/g, " ");
-    if (!Mnemonic.validate(formatted)) {
-        throw new Error("invalid BIP-39 mnemonic phrase");
-    }
-    return formatted;
-}
-function mnemonicToSeed(mnemonic, password = "") {
-    const seedHex = Mnemonic.toSeed(mnemonic, password);
-    return ByteUtils.hexStringToBytes(seedHex);
-}

package/dist/circuits.json

@@ -1,26 +0,0 @@
-{
-    "joinsplit_3x3_16": {
-        "file": "joinsplit",
-        "template": "JoinSplit",
-        "pubs": ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-        "params": [3, 3, 16]
-    },
-    "joinsplit_2x3_16": {
-        "file": "joinsplit",
-        "template": "JoinSplit",
-        "pubs": ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-        "params": [2, 3, 16]
-    },
-    "joinsplit_1x2_16": {
-        "file": "joinsplit",
-        "template": "JoinSplit",
-        "pubs": ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-        "params": [1, 2, 16]
-    },
-    "joinsplit_1x1_16": {
-        "file": "joinsplit",
-        "template": "JoinSplit",
-        "pubs": ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-        "params": [1, 1, 16]
-    }
-}

package/dist/clients/broadcaster.js

@@ -1,23 +0,0 @@
-import { createJsonHttpClient } from "./http.js";
-export function createBroadcasterClient(baseUrl, deps) {
-    const http = createJsonHttpClient(baseUrl, deps);
-    return {
-        async submitRelay(params) {
-            return http.request({
-                method: "POST",
-                path: "/relays",
-                json: {
-                    client_tx_id: params.clientTxId,
-                    chain_id: params.chainId,
-                    ...params.payload,
-                },
-            });
-        },
-        async getRelayStatus(relayId) {
-            return http.request({
-                method: "GET",
-                path: `/relays/${relayId}`,
-            });
-        },
-    };
-}

package/dist/clients/http.js

@@ -1,57 +0,0 @@
-import ky, { HTTPError, TimeoutError } from "ky";
-export class HttpError extends Error {
-    status;
-    body;
-    constructor(message, status, body) {
-        super(message);
-        this.status = status;
-        this.body = body;
-    }
-}
-async function readErrorBodySafe(res) {
-    try {
-        return await res.clone().json();
-    }
-    catch {
-        const text = await res.text();
-        return text || null;
-    }
-}
-export function createJsonHttpClient(baseUrl, deps) {
-    if (!baseUrl)
-        throw new Error("baseUrl is required");
-    if (!deps?.fetch)
-        throw new Error("deps.fetch is required");
-    // Ensure `fetch` is invoked with a global `this` to avoid "Illegal invocation"
-    // errors in some browser environments when the function is extracted. // TODO: can we fix this in another way?
-    const fetchImpl = (...args) => deps.fetch.apply(globalThis, args);
-    const api = ky.create({
-        prefixUrl: baseUrl.replace(/\/+$/, ""),
-        fetch: fetchImpl,
-    });
-    return {
-        async request(opts) {
-            try {
-                const res = api(opts.path.replace(/^\//, ""), {
-                    method: opts.method,
-                    searchParams: opts.query,
-                    json: opts.json,
-                    body: opts.body,
-                    headers: opts.headers,
-                    signal: opts.signal,
-                });
-                return await res.json();
-            }
-            catch (err) {
-                if (err instanceof HTTPError) {
-                    const body = await readErrorBodySafe(err.response);
-                    throw new HttpError(`HTTP ${err.response.status} ${err.response.statusText}`.trim(), err.response.status, body);
-                }
-                if (err instanceof TimeoutError) {
-                    throw new HttpError("HTTP timeout", 408, null);
-                }
-                throw new HttpError(err instanceof Error ? err.message : "Network error", 0, null);
-            }
-        },
-    };
-}

package/dist/clients/indexer.js

@@ -1,67 +0,0 @@
-import { createJsonHttpClient } from "./http.js";
-import { isNotFoundError } from "../utils/async.js";
-export function createIndexerClient(baseUrl, deps) {
-    const http = createJsonHttpClient(baseUrl, deps);
-    // Converts the snake_case record from the REST API into the camelCase shape
-    // the rest of the SDK consumes.
-    const normalizeRecord = (record) => ({
-        index: record.leaf_index,
-        commitment: record.commitment,
-        ciphertext: [...record.ciphertext],
-        root: record.root,
-        txHash: record.tx_hash,
-        insertedAt: record.inserted_at,
-    });
-    const normalizeNullifierRecord = (record) => ({
-        nullifier: record.nullifier,
-        txHash: record.tx_hash,
-        spentAt: record.spent_at,
-        chainId: record.chain_id,
-    });
-    return {
-        async fetchCommitmentBatch(params) {
-            const raw = await http.request({
-                method: "GET",
-                path: `/chains/${params.chainId}/commitments`,
-                query: {
-                    start: params.start,
-                    limit: params.limit,
-                },
-            });
-            return {
-                chainId: raw.chain_id,
-                commitments: raw.commitments.map(normalizeRecord),
-                latestRoot: raw.latest_root,
-            };
-        },
-        async getCommitment(params) {
-            const raw = await http.request({
-                method: "GET",
-                path: `/chains/${params.chainId}/commitments/${params.commitment}`,
-            });
-            return normalizeRecord(raw);
-        },
-        async getNullifier(params) {
-            try {
-                const raw = await http.request({
-                    method: "GET",
-                    path: `/chains/${params.chainId}/nullifiers/${params.nullifier}`,
-                });
-                return normalizeNullifierRecord(raw);
-            }
-            catch (err) {
-                if (isNotFoundError(err)) {
-                    return null; // Nullifier not spent on-chain
-                }
-                throw err;
-            }
-        },
-        async getNullifierCount(chainId) {
-            const raw = await http.request({
-                method: "GET",
-                path: `/chains/${chainId}/nullifiers/count`,
-            });
-            return raw.count;
-        },
-    };
-}

package/dist/config.js

@@ -1,29 +0,0 @@
-const DEFAULT_RPC_URL = "http://localhost:3000";
-function readEnv(key) {
-    if (typeof process !== "undefined" && process?.env) {
-        return process.env[key];
-    }
-    // Support environments where process isn't defined but a shim sets globalThis.process
-    const globalProcess = globalThis.process;
-    return globalProcess?.env?.[key];
-}
-function readServiceUrl(envKey, fallback) {
-    const raw = readEnv(envKey);
-    if (!raw)
-        return fallback;
-    const trimmed = raw.trim();
-    if (!trimmed) {
-        throw new Error(`${envKey} must not be empty when set`);
-    }
-    return trimmed.replace(/\/+$/, "");
-}
-export const serviceConfig = {
-    /**
-     * Base URL for the Broadcaster HTTP API (default: http://localhost:8081).
-     */
-    broadcasterBaseUrl: readServiceUrl("UNLINK_RPC_URL", DEFAULT_RPC_URL) + "/broadcaster",
-    /**
-     * Base URL for the Indexer HTTP API (default: http://localhost:8082).
-     */
-    indexerBaseUrl: readServiceUrl("UNLINK_RPC_URL", DEFAULT_RPC_URL) + "/indexer",
-};

package/dist/core.js

@@ -1,12 +0,0 @@
-import { migrate } from "./schema.js";
-export async function initCore(deps) {
-    if (!deps?.storage)
-        throw new Error("storage dep required");
-    if (!deps?.rng)
-        throw new Error("rng dep required");
-    await migrate(deps.storage);
-    return {
-        storage: deps.storage,
-        rng: deps.rng,
-    };
-}

package/dist/errors.js

@@ -1,18 +0,0 @@
-export class CoreError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "CoreError";
-    }
-}
-export class KeyValidationError extends CoreError {
-    constructor(message) {
-        super(message);
-        this.name = "KeyValidationError";
-    }
-}
-export class SchemaMismatchError extends CoreError {
-    constructor(current, expected) {
-        super(`schema mismatch (current ${current}, expected ${expected})`);
-        this.name = "SchemaMismatchError";
-    }
-}

package/dist/key-derivation/babyjubjub.d.ts

@@ -1,9 +0,0 @@
-/**
- * Lightweight wrapper exposing the BabyJubJub point packing helpers we rely on for
- * derivation and address encoding. Re-exported for consumers that need raw curve ops.
- */
-export declare class Babyjubjub {
-    static packPoint: (point: [bigint, bigint]) => Uint8Array;
-    static unpackPoint: (bytes: Uint8Array) => [bigint, bigint];
-}
-//# sourceMappingURL=babyjubjub.d.ts.map

package/dist/key-derivation/babyjubjub.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"babyjubjub.d.ts","sourceRoot":"","sources":["../../key-derivation/babyjubjub.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qBAAa,UAAU;IACrB,MAAM,CAAC,SAAS,0CAAqB;IAErC,MAAM,CAAC,WAAW,0CAAuB;CAC1C"}

package/dist/key-derivation/babyjubjub.js

@@ -1,9 +0,0 @@
-import { babyjub } from "@railgun-community/circomlibjs";
-/**
- * Lightweight wrapper exposing the BabyJubJub point packing helpers we rely on for
- * derivation and address encoding. Re-exported for consumers that need raw curve ops.
- */
-export class Babyjubjub {
-    static packPoint = babyjub.packPoint;
-    static unpackPoint = babyjub.unpackPoint;
-}

package/dist/key-derivation/bech32.d.ts

@@ -1,22 +0,0 @@
-export type Chain = {
-    type: number;
-    id: number;
-};
-export type AddressData = {
-    masterPublicKey: bigint;
-    viewingPublicKey: Uint8Array;
-    chain?: Chain;
-    version?: number;
-};
-export declare const ADDRESS_VERSION = 1;
-export declare const ADDRESS_LENGTH_LIMIT = 127;
-export declare const ALL_CHAINS_NETWORK_ID = "ffffffffffffffff";
-/**
- * Encode address metadata into a Bech32m string with the 0zk prefix.
- */
-export declare const encodeAddress: (addressData: AddressData) => string;
-/**
- * Decode and validate a Bech32m address, returning the structured payload.
- */
-export declare const decodeAddress: (address: string) => AddressData;
-//# sourceMappingURL=bech32.d.ts.map

package/dist/key-derivation/bech32.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bech32.d.ts","sourceRoot":"","sources":["../../key-derivation/bech32.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,UAAU,CAAC;IAC7B,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,eAAO,MAAM,qBAAqB,qBAAqB,CAAC;AA0CxD;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,aAAa,WAAW,KAAG,MAmBxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,KAAG,WAoC/C,CAAC"}

package/dist/key-derivation/bech32.js

@@ -1,86 +0,0 @@
-import { bech32m } from "@scure/base";
-import { ByteLength, ByteUtils } from "./bytes.js";
-export const ADDRESS_VERSION = 1;
-export const ADDRESS_LENGTH_LIMIT = 127;
-export const ALL_CHAINS_NETWORK_ID = "ffffffffffffffff";
-const PREFIX = "0zk";
-const XOR_SALT = new TextEncoder().encode("unlink");
-/**
- * XOR the network identifier with a static salt to keep addresses compact and avoid
- * exposing raw chain IDs directly (mirrors the reference implementation).
- */
-const xorNetworkID = (networkID) => {
-    const bytes = ByteUtils.hexStringToBytes(networkID);
-    const result = new Uint8Array(bytes.length);
-    const saltLength = XOR_SALT.length;
-    for (let i = 0; i < bytes.length; i += 1) {
-        const byte = bytes[i] ?? 0;
-        let saltByte = 0;
-        if (saltLength > 0) {
-            const saltIndex = i % saltLength;
-            saltByte = XOR_SALT[saltIndex] ?? 0;
-        }
-        result[i] = byte ^ saltByte;
-    }
-    return ByteUtils.bytesToHex(result);
-};
-const chainToNetworkID = (chain) => {
-    if (!chain)
-        return ALL_CHAINS_NETWORK_ID;
-    const { type, id } = chain;
-    const typeHex = (type & 0xff).toString(16).padStart(2, "0");
-    const idHex = BigInt(id).toString(16).padStart(14, "0");
-    return `${typeHex}${idHex}`;
-};
-const networkIDToChain = (networkID) => {
-    if (networkID === ALL_CHAINS_NETWORK_ID) {
-        return undefined;
-    }
-    const type = parseInt(networkID.slice(0, 2), 16);
-    const id = parseInt(networkID.slice(2), 16);
-    return { type, id };
-};
-/**
- * Encode address metadata into a Bech32m string with the 0zk prefix.
- */
-export const encodeAddress = (addressData) => {
-    const versionHex = (addressData.version ?? ADDRESS_VERSION)
-        .toString(16)
-        .padStart(2, "0");
-    const masterPublicKey = ByteUtils.nToHex(addressData.masterPublicKey, ByteLength.UINT_256, false);
-    const viewingPublicKey = ByteUtils.formatToByteLength(addressData.viewingPublicKey, ByteLength.UINT_256);
-    const networkID = xorNetworkID(chainToNetworkID(addressData.chain));
-    const payloadHex = `${versionHex}${masterPublicKey}${networkID}${viewingPublicKey}`;
-    const payload = ByteUtils.hexStringToBytes(payloadHex);
-    return bech32m.encode(PREFIX, bech32m.toWords(payload), ADDRESS_LENGTH_LIMIT);
-};
-/**
- * Decode and validate a Bech32m address, returning the structured payload.
- */
-export const decodeAddress = (address) => {
-    if (!address) {
-        throw new Error("No address to decode");
-    }
-    const decoded = bech32m.decode(address, ADDRESS_LENGTH_LIMIT);
-    if (decoded.prefix !== PREFIX) {
-        throw new Error("Invalid address prefix");
-    }
-    const payloadHex = ByteUtils.hexlify(bech32m.fromWords(decoded.words));
-    if (payloadHex.length !== 2 + 64 + 16 + 64) {
-        throw new Error("Incorrect address payload length");
-    }
-    const version = parseInt(payloadHex.slice(0, 2), 16);
-    if (version !== ADDRESS_VERSION) {
-        throw new Error("Incorrect address version");
-    }
-    const masterPublicKey = ByteUtils.hexToBigInt(payloadHex.slice(2, 66));
-    const networkID = xorNetworkID(payloadHex.slice(66, 82));
-    const viewingPublicKey = ByteUtils.hexStringToBytes(payloadHex.slice(82, 146));
-    const chain = networkIDToChain(networkID);
-    return {
-        version,
-        masterPublicKey,
-        viewingPublicKey,
-        chain,
-    };
-};

package/dist/key-derivation/bip32.d.ts

@@ -1,17 +0,0 @@
-export type KeyNode = {
-    chainKey: string;
-    chainCode: string;
-};
-/**
- * Parse a derivation path into hardened segment indexes.
- */
-export declare const getPathSegments: (path: string) => number[];
-/**
- * Perform hardened child derivation using the BabyJubJub curve seed.
- */
-export declare const childKeyDerivationHardened: (node: KeyNode, index: number, offset?: number) => KeyNode;
-/**
- * Create the root BIP-32 node from a BIP-39 seed.
- */
-export declare const getMasterKeyFromSeed: (seed: string) => KeyNode;
-//# sourceMappingURL=bip32.d.ts.map

package/dist/key-derivation/bip32.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bip32.d.ts","sourceRoot":"","sources":["../../key-derivation/bip32.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AASF;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,MAAM,EASpD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,0BAA0B,GACrC,MAAM,OAAO,EACb,OAAO,MAAM,EACb,SAAQ,MAAmB,KAC1B,OAOF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,KAAG,OAKnD,CAAC"}

package/dist/key-derivation/bip32.js

@@ -1,41 +0,0 @@
-import { ByteUtils, fromUTF8String } from "./bytes.js";
-import { sha512HMAC } from "./hash.js";
-const CURVE_SEED = fromUTF8String("babyjubjub seed");
-// Validates derivation paths of the form m/... with hardened segments.
-const PATH_REGEX = /^m(\/[0-9]+')+$/;
-const isValidPath = (path) => {
-    return PATH_REGEX.test(path);
-};
-/**
- * Parse a derivation path into hardened segment indexes.
- */
-export const getPathSegments = (path) => {
-    if (!isValidPath(path)) {
-        throw new Error("Invalid derivation path");
-    }
-    return path
-        .split("/")
-        .slice(1)
-        .map((segment) => segment.replace("'", ""))
-        .map((segment) => parseInt(segment, 10));
-};
-/**
- * Perform hardened child derivation using the BabyJubJub curve seed.
- */
-export const childKeyDerivationHardened = (node, index, offset = 0x80000000) => {
-    const indexFormatted = ByteUtils.padToLength(index + offset, 4);
-    const preImage = `00${node.chainKey}${indexFormatted}`;
-    const I = sha512HMAC(node.chainCode, preImage);
-    const chainKey = I.slice(0, 64);
-    const chainCode = I.slice(64);
-    return { chainKey, chainCode };
-};
-/**
- * Create the root BIP-32 node from a BIP-39 seed.
- */
-export const getMasterKeyFromSeed = (seed) => {
-    const I = sha512HMAC(CURVE_SEED, seed);
-    const chainKey = I.slice(0, 64);
-    const chainCode = I.slice(64);
-    return { chainKey, chainCode };
-};

package/dist/key-derivation/bip39.d.ts

@@ -1,22 +0,0 @@
-export declare class Mnemonic {
-    /**
-     * Generate a BIP-39 mnemonic using the English wordlist.
-     */
-    static generate(strength?: 128 | 192 | 256): string;
-    /**
-     * Validate a mnemonic against the English wordlist checksum.
-     */
-    static validate(mnemonic: string): boolean;
-    /**
-     * Convert a mnemonic to a hex-encoded BIP-39 seed. Optional password supported.
-     */
-    static toSeed(mnemonic: string, password?: string): string;
-    static toEntropy(mnemonic: string): string;
-    static fromEntropy(entropyHex: string): string;
-    /**
-     * Convenience helper: derive a 0x private key for non-0zk flows.
-     */
-    static to0xPrivateKey(mnemonic: string, derivationIndex?: number): string;
-    static to0xAddress(mnemonic: string, derivationIndex?: number): string;
-}
-//# sourceMappingURL=bip39.d.ts.map

package/dist/key-derivation/bip39.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bip39.d.ts","sourceRoot":"","sources":["../../key-derivation/bip39.ts"],"names":[],"mappings":"AAqBA,qBAAa,QAAQ;IACnB;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,QAAQ,GAAE,GAAG,GAAG,GAAG,GAAG,GAAS,GAAG,MAAM;IAIxD;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI1C;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAW,GAAG,MAAM;IAK9D,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAK1C,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAK9C;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM;IAWzE,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM;CAOvE"}

package/dist/key-derivation/bip39.js

@@ -1,56 +0,0 @@
-import { entropyToMnemonic, generateMnemonic, mnemonicToEntropy, mnemonicToSeedSync, validateMnemonic, } from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english.js";
-import { HDKey } from "ethereum-cryptography/hdkey";
-import { Mnemonic as EthersMnemonic, HDNodeWallet } from "ethers";
-import { ByteUtils } from "./bytes.js";
-/**
- * Standard ETH derivation path helper for convenience utilities below.
- * Not used for 0zk accounts but kept for backwards compatibility.
- */
-const derivationPath = (index = 0) => {
-    return `m/44'/60'/0'/0/${index}`;
-};
-export class Mnemonic {
-    /**
-     * Generate a BIP-39 mnemonic using the English wordlist.
-     */
-    static generate(strength = 128) {
-        return generateMnemonic(wordlist, strength);
-    }
-    /**
-     * Validate a mnemonic against the English wordlist checksum.
-     */
-    static validate(mnemonic) {
-        return validateMnemonic(mnemonic, wordlist);
-    }
-    /**
-     * Convert a mnemonic to a hex-encoded BIP-39 seed. Optional password supported.
-     */
-    static toSeed(mnemonic, password = "") {
-        const seed = mnemonicToSeedSync(mnemonic, password);
-        return ByteUtils.bytesToHex(seed);
-    }
-    static toEntropy(mnemonic) {
-        const entropy = mnemonicToEntropy(mnemonic, wordlist);
-        return ByteUtils.bytesToHex(entropy);
-    }
-    static fromEntropy(entropyHex) {
-        const entropy = ByteUtils.hexStringToBytes(entropyHex);
-        return entropyToMnemonic(entropy, wordlist);
-    }
-    /**
-     * Convenience helper: derive a 0x private key for non-0zk flows.
-     */
-    static to0xPrivateKey(mnemonic, derivationIndex) {
-        const seed = mnemonicToSeedSync(mnemonic);
-        const node = HDKey.fromMasterSeed(Buffer.from(seed)).derive(derivationPath(derivationIndex));
-        if (!node.privateKey) {
-            throw new Error("Failed to derive private key");
-        }
-        return ByteUtils.bytesToHex(node.privateKey);
-    }
-    static to0xAddress(mnemonic, derivationIndex) {
-        const wallet = HDNodeWallet.fromMnemonic(EthersMnemonic.fromPhrase(mnemonic), derivationPath(derivationIndex));
-        return wallet.address;
-    }
-}