paulmillr / scure-bip32 Goto Github PK

import { generateMnemonic as _generateMnemonic, mnemonicToSeed } from '@scure/bip39';
import { wordlist } from '@scure/bip39/wordlists/english';
import { HDKey } from '@scure/bip32';
import { network } from './constants';
import * as crypto from '@scure/btc-signer';

type AllowedKeyEntropyBits = 128 | 256;

export const network = {
    testnet: {
        private: 0x043587cf,
        public: 0x04358394,
    },
};

export function generateMnemonic(entropy: AllowedKeyEntropyBits = 256): string {
    if (entropy !== 256 && entropy !== 128)
      throw TypeError(
        `Incorrect entropy bits provided, expected 256 or 128 (24 or 12 word results), got: "${String(
          entropy
        )}".`
      );
    return _generateMnemonic(wordlist, entropy);
}

async function generateWallet() {
    const mnemonic = generateMnemonic();
    const masterseed = await mnemonicToSeed(mnemonic);
    const hdkey = HDKey.fromMasterSeed(masterseed, network.testnet);

    const addresses = []
    for (let i = 0; i < 5; i++) {
        const path = `m/44'/2'/0'/0/${i}`;
        const node = hdkey.derive(path);
        const address = crypto.getAddress('wpkh', node.privateKey!);
        addresses.push(address);
    }

    console.log("Addresses:", addresses);
}

generateWallet();

    const mnemonic = formControls.mnemonic.value;
    const passphrase = formControls.passphrase.value;
    const accountNumber = Number(formControls.accountNumber.value);
    const masterSeed = mnemonicToSeedSync(mnemonic, passphrase);
    
    const keys = HDKey.fromMasterSeed(masterSeed).derive(`m/44'/0'/${accountNumber}'/0/0`);

import { HDKey } from '@scure/bip32'
import { HMAC as sha256HMAC } from 'fast-sha256'
import secp256k1 from 'secp256k1'
import * as lnurl from '@zerologin/lnurl'
import { mnemonicToSeed } from "@scure/bip39"

const stringToUint8Array = (str: string) => {
    return Uint8Array.from(str, (x) => x.charCodeAt(0))
}
const seedFromWords = async (mnemonic: string) => {
    const seed = await mnemonicToSeed(mnemonic)
    return Buffer.from(seed)
}

...

const lnurlObject = lnurl.decode('lightning:LNURL1DP68GURN8GHJ7MRFVA58GMNFDENKCMM8D9HZUMRFWEJJ7MR0VA5KU0MTXY7NWCNYXSMKVCEKX3JRSCF4X3SKXWTXXASNGVE5XQ6RZDMXXC6KXDE3VYCRZCENXF3NQVF5XCEXZE3JXVMRGVRY8YURJVNYV43RGDRRVGN8GCT884KX7EMFDCV8DETA')
const lnurlDecoded = lnurlObject.decoded
const k1 = lnurlObject.k1
const domain = lnurlObject.domain


const mn = 'praise you muffin lion enable neck grocery crumble super myself license ghost'
const seed = await seedFromWords(mn)
const root = HDKey.fromMasterSeed(seed)

const hashingKey = root.derive(`m/138'/0`)
const hashingPrivKey = hashingKey.privateKey
console.log({ hashingPrivKey })


if (!hashingPrivKey) throw new Error('Cannot derive pub key')
const derivationMaterial = new sha256HMAC(hashingPrivKey).update(stringToUint8Array(domain)).digest()
console.log({ derivationMaterial })
const pathSuffix = new Uint32Array(derivationMaterial.buffer.slice(0, 16))
console.log({ pathSuffix })
const path = `m/138'/${pathSuffix.join('/')}`
console.log({ path }) // m/138'/2770944631/3393836580/3568300899/2659809102

const linkingKey = root.derive(path) // throw an error "Invalid index"