chore: include dist/ directory in version control

- Remove dist/ from .gitignore as this is a library package
- Add compiled output for both ESM and CommonJS formats
- Include source maps and type definitions

Author: vveerrgg

.gitignore

@@ -4,10 +4,9 @@ npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 
-# Build output
-dist/
-build/
+# Build artifacts
 *.tsbuildinfo
+*.tgz
 
 # IDE and editor files
 .idea/
@@ -23,3 +22,6 @@ coverage/
 .env
 .env.local
 .env.*.local
+
+# Project specific
+CHECKLIST.md

dist/__mocks__/@noble/secp256k1.d.ts

@@ -0,0 +1,26 @@
+import { bytesToHex as originalBytesToHex, hexToBytes as originalHexToBytes } from "@noble/hashes/utils";
+export declare function getPublicKey(privateKey: Uint8Array | string): Uint8Array;
+export declare const schnorr: {
+    sign(message: Uint8Array | string, privateKey: Uint8Array | string): Promise<Uint8Array>;
+    verify(signature: Uint8Array | string, message: Uint8Array | string, publicKey: Uint8Array | string): Promise<boolean>;
+};
+export declare const utils: {
+    bytesToHex: typeof originalBytesToHex;
+    hexToBytes: typeof originalHexToBytes;
+    isValidPrivateKey(key: Uint8Array | string): boolean;
+    randomPrivateKey(): Uint8Array;
+};
+declare const _default: {
+    getPublicKey: typeof getPublicKey;
+    schnorr: {
+        sign(message: Uint8Array | string, privateKey: Uint8Array | string): Promise<Uint8Array>;
+        verify(signature: Uint8Array | string, message: Uint8Array | string, publicKey: Uint8Array | string): Promise<boolean>;
+    };
+    utils: {
+        bytesToHex: typeof originalBytesToHex;
+        hexToBytes: typeof originalHexToBytes;
+        isValidPrivateKey(key: Uint8Array | string): boolean;
+        randomPrivateKey(): Uint8Array;
+    };
+};
+export default _default;

dist/__mocks__/@noble/secp256k1.js

@@ -0,0 +1,70 @@
+// Mock implementation of @noble/secp256k1 for testing
+import { bytesToHex as originalBytesToHex, hexToBytes as originalHexToBytes } from "@noble/hashes/utils";
+function ensureUint8Array(input) {
+    if (input instanceof Uint8Array)
+        return input;
+    if (typeof input === 'string')
+        return originalHexToBytes(input);
+    throw new Error('Input must be Uint8Array or hex string');
+}
+function createMockPublicKey(privateKey) {
+    // Create a deterministic 33-byte compressed public key
+    const mockPubKey = new Uint8Array(33);
+    mockPubKey[0] = 0x02; // Compressed format prefix
+    // Use private key to generate a deterministic public key
+    for (let i = 0; i < 32; i++) {
+        mockPubKey[i + 1] = privateKey[i] ^ 0x02; // XOR with 0x02 to make it different from private key
+    }
+    return mockPubKey;
+}
+// Mock point multiplication for public key derivation
+export function getPublicKey(privateKey) {
+    const privKeyBytes = ensureUint8Array(privateKey);
+    if (privKeyBytes.length !== 32) {
+        throw new Error('Private key must be 32 bytes');
+    }
+    return createMockPublicKey(privKeyBytes);
+}
+// Mock signature creation
+export const schnorr = {
+    sign(message, privateKey) {
+        const msgBytes = ensureUint8Array(message);
+        const privKeyBytes = ensureUint8Array(privateKey);
+        const signature = new Uint8Array(64);
+        // Create a deterministic signature
+        for (let i = 0; i < 32; i++) {
+            signature[i] = msgBytes[i % msgBytes.length];
+            signature[i + 32] = privKeyBytes[i];
+        }
+        return Promise.resolve(signature);
+    },
+    verify(signature, message, publicKey) {
+        return Promise.resolve(true);
+    }
+};
+// Mock utility functions
+export const utils = {
+    bytesToHex: originalBytesToHex,
+    hexToBytes: originalHexToBytes,
+    isValidPrivateKey(key) {
+        try {
+            const keyBytes = ensureUint8Array(key);
+            return keyBytes.length === 32;
+        }
+        catch {
+            return false;
+        }
+    },
+    randomPrivateKey() {
+        const privateKey = new Uint8Array(32);
+        for (let i = 0; i < 32; i++) {
+            privateKey[i] = Math.floor(Math.random() * 256);
+        }
+        return privateKey;
+    }
+};
+export default {
+    getPublicKey,
+    schnorr,
+    utils
+};

dist/__mocks__/bech32.d.ts

@@ -0,0 +1,14 @@
+declare function toWords(data: Uint8Array): number[];
+declare function fromWords(words: number[]): number[];
+declare function encode(prefix: string, words: number[], limit: number): string;
+declare function decode(str: string, limit?: number): {
+    prefix: string;
+    words: number[];
+};
+export declare const bech32: {
+    toWords: typeof toWords;
+    fromWords: typeof fromWords;
+    encode: typeof encode;
+    decode: typeof decode;
+};
+export {};

dist/__mocks__/bech32.js

@@ -0,0 +1,42 @@
+// Mock implementation of bech32 for testing
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+function toWords(data) {
+    // Convert bytes to 5-bit words
+    const words = [];
+    for (let i = 0; i < data.length; i++) {
+        words.push(data[i] & 0x1f); // Take the lower 5 bits
+    }
+    return words;
+}
+function fromWords(words) {
+    // Convert 5-bit words back to bytes
+    // Return number[] to match real bech32 library behavior
+    const data = new Uint8Array(words.length);
+    for (let i = 0; i < words.length; i++) {
+        data[i] = words[i] & 0xff;
+    }
+    return Array.from(data);
+}
+function encode(prefix, words, limit) {
+    // Simple mock encoding: prefix1<hex>
+    const data = Uint8Array.from(words);
+    return `${prefix}1${bytesToHex(data)}`;
+}
+function decode(str, limit) {
+    // Simple mock decoding: split on '1'
+    const [prefix, data] = str.split('1');
+    if (!prefix || !data) {
+        throw new Error('Invalid bech32 string');
+    }
+    const bytes = hexToBytes(data);
+    return {
+        prefix,
+        words: Array.from(bytes).map(b => b & 0x1f) // Convert to 5-bit words
+    };
+}
+export const bech32 = {
+    toWords,
+    fromWords,
+    encode,
+    decode
+};

dist/__mocks__/bip39.d.ts

@@ -0,0 +1,3 @@
+export declare function generateMnemonic(): string;
+export declare function validateMnemonic(mnemonic: string): boolean;
+export declare function mnemonicToEntropy(mnemonic: string): string;

dist/__mocks__/bip39.js

@@ -0,0 +1,38 @@
+// Mock implementation of bip39 for testing
+import { bytesToHex } from "@noble/hashes/utils";
+const VALID_SEED_PHRASE = "witch collapse practice feed shame open despair creek road again ice least";
+const VALID_ENTROPY = "000102030405060708090a0b0c0d0e0f";
+export function generateMnemonic() {
+    return VALID_SEED_PHRASE;
+}
+export function validateMnemonic(mnemonic) {
+    console.log("Mock validateMnemonic called with:", mnemonic);
+    // Accept the specific test mnemonic or any 12-word phrase
+    if (mnemonic === VALID_SEED_PHRASE) {
+        console.log("Valid test phrase detected");
+        return true;
+    }
+    const words = mnemonic.split(" ");
+    const isValid = words.length === 12 && words.every(word => word.length > 0);
+    console.log(`Validation result for "${mnemonic}": ${isValid}`);
+    return isValid;
+}
+export function mnemonicToEntropy(mnemonic) {
+    console.log("Mock mnemonicToEntropy called with:", mnemonic);
+    if (!validateMnemonic(mnemonic)) {
+        throw new Error("Invalid mnemonic");
+    }
+    // For testing, return a fixed valid entropy for our test seed phrase
+    if (mnemonic === VALID_SEED_PHRASE) {
+        console.log("Returning test entropy");
+        return VALID_ENTROPY;
+    }
+    // For other valid phrases, generate a deterministic entropy
+    console.log("Generating deterministic entropy");
+    const words = mnemonic.split(" ");
+    const entropy = new Uint8Array(16); // 16 bytes = 128 bits
+    for (let i = 0; i < 16; i++) {
+        entropy[i] = (i + 1) % 256; // Simple deterministic pattern
+    }
+    return bytesToHex(entropy);
+}

dist/__tests__/index.test.d.ts

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