@unlink-xyz/core 0.1.2 → 0.1.3-canary.06c36a8

package/dist/account/{zkAccount.d.ts → account.d.ts}

@@ -1,4 +1,4 @@
-import { type SpendingKeyPair, type ViewingKeyPair } from "../key-derivation/wallet-node.js";
+import { type SpendingKeyPair, type ViewingKeyPair } from "../keys/derive.js";
 import type { Storage } from "../types.js";
 export type MasterSeedCrypto = {
     encrypt(seed: Uint8Array): Promise<Uint8Array> | Uint8Array;
@@ -14,14 +14,16 @@ export type GenerateMasterSeedOptions = {
 export declare const MASTER_SEED_LENGTH = 64;
 export declare const MASTER_SEED_KEY = "cfg:wallet:master_seed/v1";
 export declare const MASTER_MNEMONIC_KEY = "cfg:wallet:master_mnemonic/v1";
-export type ZkAccount = {
+export type Account = {
     spendingKeyPair: SpendingKeyPair;
     viewingKeyPair: ViewingKeyPair;
     nullifyingKey: bigint;
     masterPublicKey: bigint;
+    /** Bech32m address (0zk1...) for this account */
+    address: string;
 };
-export declare function deriveZkAccount(masterSeed: Uint8Array, accountIndex?: number): Promise<ZkAccount>;
-export declare function deriveZkAccountFromMnemonic(mnemonic: string, accountIndex?: number, password?: string): Promise<ZkAccount>;
+export declare function deriveAccount(masterSeed: Uint8Array, accountIndex?: number): Promise<Account>;
+export declare function deriveAccountFromMnemonic(mnemonic: string, accountIndex?: number, password?: string): Promise<Account>;
 export declare function generateMasterSeed({ storage, rng, crypto, overwrite, mnemonicPassphrase, }: GenerateMasterSeedOptions): Promise<Uint8Array>;
 export declare function loadMasterSeed(storage: Storage, crypto?: MasterSeedCrypto): Promise<Uint8Array | null>;
 export declare function storeMasterSeed(storage: Storage, seed: Uint8Array, crypto?: MasterSeedCrypto): Promise<void>;
@@ -35,4 +37,4 @@ export type ImportMasterMnemonicOptions = {
 };
 export declare function importMasterMnemonic({ storage, mnemonic, crypto, overwrite, password, }: ImportMasterMnemonicOptions): Promise<Uint8Array>;
 export declare function storeMasterMnemonic(storage: Storage, mnemonic: string, crypto?: MasterSeedCrypto): Promise<void>;
-//# sourceMappingURL=zkAccount.d.ts.map
+//# sourceMappingURL=account.d.ts.map

package/dist/account/account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../account/account.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAG3C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC;IAC5D,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC;CAChE,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,UAAU,CAAC;IAC/B,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,eAAe,8BAA8B,CAAC;AAC3D,eAAO,MAAM,mBAAmB,kCAAkC,CAAC;AAOnE,MAAM,MAAM,OAAO,GAAG;IACpB,eAAe,EAAE,eAAe,CAAC;IACjC,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,wBAAsB,aAAa,CACjC,UAAU,EAAE,UAAU,EACtB,YAAY,GAAE,MAAU,GACvB,OAAO,CAAC,OAAO,CAAC,CAmBlB;AAED,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,MAAM,EAChB,YAAY,GAAE,MAAU,EACxB,QAAQ,GAAE,MAAW,GACpB,OAAO,CAAC,OAAO,CAAC,CAQlB;AAQD,wBAAsB,kBAAkB,CAAC,EACvC,OAAO,EACP,GAAG,EACH,MAAiC,EACjC,SAAiB,EACjB,kBAAkB,GACnB,EAAE,yBAAyB,GAAG,OAAO,CAAC,UAAU,CAAC,CAgCjD;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,EAChB,MAAM,GAAE,gBAA2C,GAClD,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAK5B;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,UAAU,EAChB,MAAM,GAAE,gBAA2C,GAClD,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,OAAO,EAChB,MAAM,GAAE,gBAA2C,GAClD,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAUxB;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAsB,oBAAoB,CAAC,EACzC,OAAO,EACP,QAAQ,EACR,MAAiC,EACjC,SAAiB,EACjB,QAAa,GACd,EAAE,2BAA2B,GAAG,OAAO,CAAC,UAAU,CAAC,CAenD;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,gBAA2C,GAClD,OAAO,CAAC,IAAI,CAAC,CASf"}

package/dist/account/{zkAccount.js → account.js}

@@ -1,41 +1,47 @@
-import { Mnemonic } from "../key-derivation/bip39.js";
-import { ByteUtils } from "../key-derivation/bytes.js";
-import { deriveNodesFromSeed, WalletNode, } from "../key-derivation/wallet-node.js";
+import { ValidationError } from "../errors.js";
+import { encodeAddress } from "../keys/address.js";
+import { deriveAccountKeys, } from "../keys/derive.js";
+import { Hex } from "../keys/hex.js";
+import { Mnemonic } from "../keys/mnemonic.js";
+import { zeroize } from "../utils/secure-memory.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) {
+export async function deriveAccount(masterSeed, accountIndex = 0) {
     const seed = normalizeMasterSeed(masterSeed);
     if (!Number.isInteger(accountIndex) || accountIndex < 0) {
-        throw new Error("accountIndex must be a non-negative integer");
+        throw new ValidationError("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);
+    const keys = await deriveAccountKeys(seed, accountIndex);
+    const address = encodeAddress({
+        masterPublicKey: keys.masterPublicKey,
+        viewingPublicKey: keys.viewing.pubkey,
+    });
     return {
-        spendingKeyPair,
-        viewingKeyPair,
-        nullifyingKey,
-        masterPublicKey,
+        spendingKeyPair: keys.spending,
+        viewingKeyPair: keys.viewing,
+        nullifyingKey: keys.nullifyingKey,
+        masterPublicKey: keys.masterPublicKey,
+        address,
     };
 }
-export async function deriveZkAccountFromMnemonic(mnemonic, accountIndex = 0, password = "") {
+export async function deriveAccountFromMnemonic(mnemonic, accountIndex = 0, password = "") {
     const normalized = normalizeMnemonic(mnemonic);
     const seed = mnemonicToSeed(normalized, password);
-    return deriveZkAccount(seed, accountIndex);
+    try {
+        return await deriveAccount(seed, accountIndex);
+    }
+    finally {
+        zeroize(seed);
+    }
 }
+/** Passthrough crypto, storage handles buffer isolation */
 const identityMasterSeedCrypto = {
-    encrypt(seed) {
-        return clone(seed);
-    },
-    decrypt(payload) {
-        return clone(payload);
-    },
+    encrypt: (seed) => seed,
+    decrypt: (payload) => payload,
 };
 export async function generateMasterSeed({ storage, rng, crypto = identityMasterSeedCrypto, overwrite = false, mnemonicPassphrase, }) {
     if (!overwrite) {
@@ -51,13 +57,18 @@ export async function generateMasterSeed({ storage, rng, crypto = identityMaster
     }
     const entropy = rng(MNEMONIC_ENTROPY_BYTES);
     if (entropy.length !== MNEMONIC_ENTROPY_BYTES) {
-        throw new Error(`mnemonic entropy must be ${MNEMONIC_ENTROPY_BYTES} bytes`);
+        throw new ValidationError(`mnemonic entropy must be ${MNEMONIC_ENTROPY_BYTES} bytes`);
+    }
+    try {
+        const mnemonic = Mnemonic.fromEntropy(Hex.fromBytes(entropy));
+        await storeMasterMnemonic(storage, mnemonic, crypto);
+        const seed = mnemonicToSeed(mnemonic, mnemonicPassphrase);
+        await storeMasterSeed(storage, seed, crypto);
+        return seed;
+    }
+    finally {
+        zeroize(entropy);
     }
-    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);
@@ -70,23 +81,28 @@ export async function storeMasterSeed(storage, seed, crypto = identityMasterSeed
     const normalized = normalizeMasterSeed(seed);
     const encrypted = await crypto.encrypt(normalized);
     if (!(encrypted instanceof Uint8Array)) {
-        throw new Error("master seed encryptor must return Uint8Array");
+        throw new ValidationError("master seed encryptor must return Uint8Array");
     }
-    await storage.put(MASTER_SEED_KEY, clone(encrypted));
+    await storage.put(MASTER_SEED_KEY, 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);
+    try {
+        const mnemonic = textDecoder.decode(plaintext);
+        return normalizeMnemonic(mnemonic);
+    }
+    finally {
+        zeroize(plaintext);
+    }
 }
 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");
+            throw new ValidationError("master mnemonic already exists; set overwrite to true to replace it");
         }
     }
     const normalized = normalizeMnemonic(mnemonic);
@@ -99,30 +115,28 @@ export async function storeMasterMnemonic(storage, mnemonic, crypto = identityMa
     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");
+        throw new ValidationError("master mnemonic encryptor must return Uint8Array");
     }
-    await storage.put(MASTER_MNEMONIC_KEY, clone(encrypted));
-}
-function clone(bytes) {
-    return new Uint8Array(bytes);
+    await storage.put(MASTER_MNEMONIC_KEY, encrypted);
 }
+/** Validates seed format. Storage handles buffer isolation on put/get. */
 function normalizeMasterSeed(seed) {
     if (!(seed instanceof Uint8Array)) {
-        throw new Error("master seed must be a Uint8Array");
+        throw new ValidationError("master seed must be a Uint8Array");
     }
     if (seed.length !== MASTER_SEED_LENGTH) {
-        throw new Error(`master seed must be ${MASTER_SEED_LENGTH} bytes`);
+        throw new ValidationError(`master seed must be ${MASTER_SEED_LENGTH} bytes`);
     }
-    return clone(seed);
+    return seed;
 }
 function normalizeMnemonic(mnemonic) {
     const formatted = mnemonic.trim().replace(/\s+/g, " ");
     if (!Mnemonic.validate(formatted)) {
-        throw new Error("invalid BIP-39 mnemonic phrase");
+        throw new ValidationError("invalid BIP-39 mnemonic phrase");
     }
     return formatted;
 }
 function mnemonicToSeed(mnemonic, password = "") {
     const seedHex = Mnemonic.toSeed(mnemonic, password);
-    return ByteUtils.hexStringToBytes(seedHex);
+    return Hex.toBytes(seedHex);
 }