@bsv/sdk 1.0.0

package/src/compat/HD.ts

@@ -0,0 +1,348 @@
+import { fromBase58Check, toBase58Check, Writer, Reader, toArray, toHex } from '../primitives/utils.js'
+import * as Hash from '../primitives/Hash.js'
+import Curve from '../primitives/Curve.js'
+import PrivateKey from '../primitives/PrivateKey.js'
+import PublicKey from '../primitives/PublicKey.js'
+import Random from '../primitives/Random.js'
+import BigNumber from '../primitives/BigNumber.js'
+
+/**
+ * @deprecated
+ * The HD class implements the Bitcoin Improvement Proposal 32 (BIP32) hierarchical deterministic wallets.
+ * It allows the generation of child keys from a master key, ensuring a tree-like structure of keys and addresses.
+ * This class is deprecated due to the introduction of BRC-42, which offers an enhanced key derivation scheme.
+ * BRC-42 uses invoice numbers for key derivation, improving privacy and scalability compared to BIP32.
+ * 
+ * @class HD
+ * @deprecated Replaced by BRC-42 which uses invoice numbers and supports private derivation.
+ */
+export default class HD {
+    versionBytesNum: number
+    depth: number
+    parentFingerPrint: number[]
+    childIndex: number
+    chainCode: number[]
+    privKey: PrivateKey
+    pubKey: PublicKey
+    constants = {
+        pubKey: 0x0488b21e,
+        privKey: 0x0488ade4
+    }
+
+    /**
+     * Constructor for the BIP32 HD wallet.
+     * Initializes an HD wallet with optional parameters for version bytes, depth, parent fingerprint, child index, chain code, private key, and public key.
+     * @param versionBytesNum - Version bytes number for the wallet.
+     * @param depth - Depth of the key in the hierarchy.
+     * @param parentFingerPrint - Fingerprint of the parent key.
+     * @param childIndex - Index of the child key.
+     * @param chainCode - Chain code for key derivation.
+     * @param privKey - Private key of the wallet.
+     * @param pubKey - Public key of the wallet.
+     */
+    constructor(
+        versionBytesNum?: number,
+        depth?: number,
+        parentFingerPrint?: number[],
+        childIndex?: number,
+        chainCode?: number[],
+        privKey?: PrivateKey,
+        pubKey?: PublicKey
+    ) {
+        this.versionBytesNum = versionBytesNum
+        this.depth = depth
+        this.parentFingerPrint = parentFingerPrint
+        this.childIndex = childIndex
+        this.chainCode = chainCode
+        this.privKey = privKey
+        this.pubKey = pubKey
+    }
+
+    /**
+     * Generates a new HD wallet with random keys.
+     * This method creates a root HD wallet with randomly generated private and public keys.
+     * @returns {HD} The current HD instance with generated keys.
+     */
+    public fromRandom(): this {
+        this.versionBytesNum = this.constants.privKey
+        this.depth = 0x00
+        this.parentFingerPrint = [0, 0, 0, 0]
+        this.childIndex = 0
+        this.chainCode = Random(32)
+        this.privKey = PrivateKey.fromRandom()
+        this.pubKey = this.privKey.toPublicKey()
+        return this
+    }
+
+    /**
+     * Generates a new HD wallet with random keys.
+     * This method creates a root HD wallet with randomly generated private and public keys.
+     * @returns {HD} A new HD instance with generated keys.
+     * @static
+     */
+    public static fromRandom(): HD {
+        return new this().fromRandom()
+    }
+
+    /**
+     * Initializes the HD wallet from a given base58 encoded string.
+     * This method decodes a provided string to set up the HD wallet's properties.
+     * @param str - A base58 encoded string representing the wallet.
+     * @returns {HD} The current instance with properties set from the string.
+     */
+    public fromString(str: string): this {
+        const decoded = fromBase58Check(str)
+        return this.fromBinary([...decoded.prefix, ...decoded.data] as number[])
+    }
+
+    /**
+     * Converts the HD wallet to a base58 encoded string.
+     * This method provides a string representation of the HD wallet's current state.
+     * @returns {string} A base58 encoded string of the HD wallet.
+     */
+    public toString(): string {
+        const bin = this.toBinary()
+        return toBase58Check(bin, [])
+    }
+
+    /**
+     * Initializes the HD wallet from a seed.
+     * This method generates keys and other properties from a given seed, conforming to the BIP32 specification.
+     * @param bytes - An array of bytes representing the seed.
+     * @returns {HD} The current instance with properties set from the seed.
+     */
+    public fromSeed(bytes: number[]): this {
+        if (bytes.length < 128 / 8) {
+            throw new Error('Need more than 128 bits of entropy')
+        }
+        if (bytes.length > 512 / 8) {
+            throw new Error('More than 512 bits of entropy is nonstandard')
+        }
+        const hash: number[] = Hash.sha512hmac(toArray('Bitcoin seed', 'utf8'), bytes) as number[]
+
+        this.depth = 0x00
+        this.parentFingerPrint = [0, 0, 0, 0]
+        this.childIndex = 0
+        this.chainCode = hash.slice(32, 64)
+        this.versionBytesNum = this.constants.privKey
+        this.privKey = new PrivateKey(hash.slice(0, 32))
+        this.pubKey = this.privKey.toPublicKey()
+
+        return this
+    }
+
+    /**
+     * Initializes the HD wallet from a seed.
+     * This method generates keys and other properties from a given seed, conforming to the BIP32 specification.
+     * @param bytes - An array of bytes representing the seed.
+     * @returns {HD} The current instance with properties set from the seed.
+     */
+    public static fromSeed(bytes: number[]): HD {
+        return new this().fromSeed(bytes)
+    }
+
+    /**
+     * Initializes the HD wallet from a binary buffer.
+     * Parses a binary buffer to set up the wallet's properties.
+     * @param buf - A buffer containing the wallet data.
+     * @returns {HD} The current instance with properties set from the buffer.
+     */
+    public fromBinary(buf: number[]): this {
+        // Both pub and private extended keys are 78 buf
+        if (buf.length !== 78) {
+            throw new Error('incorrect bip32 data length')
+        }
+        const reader = new Reader(buf)
+
+        this.versionBytesNum = reader.readUInt32BE()
+        this.depth = reader.readUInt8()
+        this.parentFingerPrint = reader.read(4)
+        this.childIndex = reader.readUInt32BE()
+        this.chainCode = reader.read(32)
+        const keyBytes = reader.read(33)
+
+        const isPrivate = this.versionBytesNum === this.constants.privKey
+        const isPublic = this.versionBytesNum === this.constants.pubKey
+
+        if (isPrivate && keyBytes[0] === 0) {
+            this.privKey = new PrivateKey(keyBytes.slice(1, 33))
+            this.pubKey = this.privKey.toPublicKey()
+        } else if (isPublic && (keyBytes[0] === 0x02 || keyBytes[0] === 0x03)) {
+            this.pubKey = PublicKey.fromString(toHex(keyBytes))
+        } else {
+            throw new Error('Invalid key')
+        }
+
+        return this
+    }
+
+    /**
+     * Derives a child HD wallet based on a given path.
+     * The path specifies the hierarchy of the child key to be derived.
+     * @param path - A string representing the derivation path (e.g., 'm/0'/1).
+     * @returns {HD} A new HD instance representing the derived child wallet.
+     */
+    public derive(path: string): HD {
+        if (path === 'm') {
+            return this
+        }
+
+        const e = path.split('/')
+
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let bip32: HD = this
+        for (const i in e) {
+            const c = e[i]
+
+            if (i === '0') {
+                if (c !== 'm') {
+                    throw new Error('invalid path')
+                }
+                continue
+            }
+
+            if (parseInt(c.replace("'", ''), 10).toString() !== c.replace("'", '')) {
+                throw new Error('invalid path')
+            }
+
+            const usePrivate = c.length > 1 && c[c.length - 1] === "'"
+            let childIndex = parseInt(usePrivate ? c.slice(0, c.length - 1) : c, 10) & 0x7fffffff
+
+            if (usePrivate) {
+                childIndex += 0x80000000
+            }
+
+            bip32 = bip32.deriveChild(childIndex)
+        }
+
+        return bip32
+    }
+
+    /**
+     * Derives a child HD wallet from the current wallet based on an index.
+     * This method generates either a private or public child key depending on the current wallet's state.
+     * @param i - The index of the child key to derive.
+     * @returns {HD} A new HD instance representing the derived child wallet.
+     */
+    public deriveChild(i: number): HD {
+        if (typeof i !== 'number') {
+            throw new Error('i must be a number')
+        }
+
+        const ibc: number[] = []
+        ibc.push((i >> 24) & 0xff)
+        ibc.push((i >> 16) & 0xff)
+        ibc.push((i >> 8) & 0xff)
+        ibc.push(i & 0xff)
+        const ib = [...ibc]
+
+        const usePrivate = (i & 0x80000000) !== 0
+
+        const isPrivate = this.versionBytesNum === this.constants.privKey
+
+        if (usePrivate && (!this.privKey || !isPrivate)) {
+            throw new Error('Cannot do private key derivation without private key')
+        }
+
+        let ret = null
+        if (this.privKey) {
+            let data = null
+
+            if (usePrivate) {
+                data = [0, ...this.privKey.toArray('be', 32), ...ib]
+            } else {
+                data = [...this.pubKey.encode(true) as number[], ...ib]
+            }
+
+            const hash = Hash.sha512hmac(this.chainCode, data)
+            const il = new BigNumber(hash.slice(0, 32))
+            const ir = hash.slice(32, 64)
+
+            // ki = IL + kpar (mod n).
+            const k = il.add(this.privKey).mod(new Curve().n)
+
+            ret = new HD()
+            ret.chainCode = ir
+
+            ret.privKey = new PrivateKey(k.toArray())
+            ret.pubKey = ret.privKey.toPublicKey()
+        } else {
+            const data = [...this.pubKey.encode(true) as number[], ...ib]
+            const hash = Hash.sha512hmac(this.chainCode, data)
+            const il = new BigNumber(hash.slice(0, 32))
+            const ir = hash.slice(32, 64)
+
+            // Ki = (IL + kpar)*G = IL*G + Kpar
+            const ilG = new Curve().g.mul(il)
+            const Kpar = this.pubKey
+            const Ki = ilG.add(Kpar)
+            const newpub = new PublicKey(Ki.x, Ki.y)
+
+            ret = new HD()
+            ret.chainCode = ir
+
+            ret.pubKey = newpub
+        }
+
+        ret.childIndex = i
+        const pubKeyhash = Hash.hash160(this.pubKey.encode(true))
+        ret.parentFingerPrint = pubKeyhash.slice(0, 4)
+        ret.versionBytesNum = this.versionBytesNum
+        ret.depth = this.depth + 1
+
+        return ret
+    }
+
+    /**
+     * Converts the current HD wallet to a public-only wallet.
+     * This method strips away the private key information, leaving only the public part.
+     * @returns {HD} A new HD instance representing the public-only wallet.
+     */
+    public toPublic(): HD {
+        const bip32 = new HD(this.versionBytesNum, this.depth, this.parentFingerPrint, this.childIndex, this.chainCode, this.privKey, this.pubKey)
+        bip32.versionBytesNum = this.constants.pubKey
+        bip32.privKey = undefined
+        return bip32
+    }
+
+    /**
+     * Converts the HD wallet into a binary representation.
+     * This method serializes the wallet's properties into a binary format.
+     * @returns {number[]} An array of numbers representing the binary data of the wallet.
+     */
+    public toBinary(): number[] {
+        const isPrivate = this.versionBytesNum === this.constants.privKey
+        const isPublic = this.versionBytesNum === this.constants.pubKey
+        if (isPrivate) {
+            return new Writer()
+                .writeUInt32BE(this.versionBytesNum)
+                .writeUInt8(this.depth)
+                .write(this.parentFingerPrint)
+                .writeUInt32BE(this.childIndex)
+                .write(this.chainCode)
+                .writeUInt8(0)
+                .write(this.privKey.toArray('be', 32))
+                .toArray()
+        } else if (isPublic) {
+            return new Writer()
+                .writeUInt32BE(this.versionBytesNum)
+                .writeUInt8(this.depth)
+                .write(this.parentFingerPrint)
+                .writeUInt32BE(this.childIndex)
+                .write(this.chainCode)
+                .write(this.pubKey.encode(true) as number[])
+                .toArray()
+        } else {
+            throw new Error('bip32: invalid versionBytesNum byte')
+        }
+    }
+
+    /**
+     * Checks if the HD wallet contains a private key.
+     * This method determines whether the wallet is a private key wallet or a public key only wallet.
+     * @returns {boolean} A boolean value indicating whether the wallet has a private key (true) or not (false).
+     */
+    public isPrivate(): boolean {
+        return this.versionBytesNum === this.constants.privKey
+    }
+}

package/src/compat/Mnemonic.ts

@@ -0,0 +1,295 @@
+import { wordList } from './bip-39-wordlist-en.js'
+import { encode, toArray, Reader, Writer } from '../primitives/utils.js'
+import * as Hash from '../primitives/Hash.js'
+import Random from '../primitives/Random.js'
+
+/**
+ * @class Mnemonic
+ * 
+ * @description
+ * Class representing Mnemonic functionality.
+ * This class provides methods for generating, converting, and validating mnemonic phrases
+ * according to the BIP39 standard. It supports creating mnemonics from random entropy,
+ * converting mnemonics to seeds, and validating mnemonic phrases.
+ */
+export default class Mnemonic {
+    public mnemonic: string
+    public seed: number[]
+    public Wordlist: { value: string[]; space: string }
+
+    /**
+     * Constructs a Mnemonic object.
+     * @param {string} [mnemonic] - An optional mnemonic phrase.
+     * @param {number[]} [seed] - An optional seed derived from the mnemonic.
+     * @param {object} [wordlist=wordList] - An object containing a list of words and space character used in the mnemonic.
+     */
+    constructor(mnemonic?: string, seed?: number[], wordlist = wordList) {
+        this.mnemonic = mnemonic
+        this.seed = seed
+        this.Wordlist = wordlist
+    }
+
+    /**
+     * Converts the mnemonic and seed into a binary representation.
+     * @returns {number[]} The binary representation of the mnemonic and seed.
+     */
+    public toBinary(): number[] {
+        const bw = new Writer()
+        if (this.mnemonic) {
+            const buf = toArray(this.mnemonic, 'utf8')
+            bw.writeVarIntNum(buf.length)
+            bw.write(buf)
+        } else {
+            bw.writeVarIntNum(0)
+        }
+        if (this.seed) {
+            bw.writeVarIntNum(this.seed.length)
+            bw.write(this.seed)
+        } else {
+            bw.writeVarIntNum(0)
+        }
+        return bw.toArray()
+    }
+
+    /**
+     * Loads a mnemonic and seed from a binary representation.
+     * @param {number[]} bin - The binary representation of a mnemonic and seed.
+     * @returns {this} The Mnemonic instance with loaded mnemonic and seed.
+     */
+    public fromBinary(bin: number[]): this {
+        const br = new Reader(bin)
+        const mnemoniclen = br.readVarIntNum()
+        if (mnemoniclen > 0) {
+            this.mnemonic = encode(br.read(mnemoniclen), 'utf8') as string
+        }
+        const seedlen = br.readVarIntNum()
+        if (seedlen > 0) {
+            this.seed = br.read(seedlen)
+        }
+        return this
+    }
+
+    /**
+     * Generates a random mnemonic from a given bit length.
+     * @param {number} [bits=128] - The bit length for the random mnemonic (must be a multiple of 32 and at least 128).
+     * @returns {this} The Mnemonic instance with the new random mnemonic.
+     * @throws {Error} If the bit length is not a multiple of 32 or is less than 128.
+     */
+    public fromRandom(bits?: number): this {
+        if (!bits) {
+            bits = 128
+        }
+        if (bits % 32 !== 0) {
+            throw new Error('bits must be multiple of 32')
+        }
+        if (bits < 128) {
+            throw new Error('bits must be at least 128')
+        }
+        const buf = Random(bits / 8)
+        this.entropy2Mnemonic(buf)
+        this.mnemonic2Seed()
+        return this
+    }
+
+    /**
+     * Static method to generate a Mnemonic instance with a random mnemonic.
+     * @param {number} [bits=128] - The bit length for the random mnemonic.
+     * @returns {Mnemonic} A new Mnemonic instance.
+     */
+    public static fromRandom(bits?: number): Mnemonic {
+        return new this().fromRandom(bits)
+    }
+
+    /**
+     * Converts given entropy into a mnemonic phrase.
+     * This method is used to generate a mnemonic from a specific entropy source.
+     * @param {number[]} buf - The entropy buffer, must be at least 128 bits.
+     * @returns {this} The Mnemonic instance with the mnemonic set from the given entropy.
+     * @throws {Error} If the entropy is less than 128 bits.
+     */
+    public fromEntropy(buf: number[]): this {
+        this.entropy2Mnemonic(buf)
+        return this
+    }
+
+    /**
+     * Static method to create a Mnemonic instance from a given entropy.
+     * @param {number[]} buf - The entropy buffer.
+     * @returns {Mnemonic} A new Mnemonic instance.
+     */
+    public static fromEntropy(buf: number[]): Mnemonic {
+        return new this().fromEntropy(buf)
+    }
+
+    /**
+     * Sets the mnemonic for the instance from a string.
+     * @param {string} mnemonic - The mnemonic phrase as a string.
+     * @returns {this} The Mnemonic instance with the set mnemonic.
+     */
+    public fromString(mnemonic: string): this {
+        this.mnemonic = mnemonic
+        return this
+    }
+
+    /**
+     * Static method to create a Mnemonic instance from a mnemonic string.
+     * @param {string} str - The mnemonic phrase.
+     * @returns {Mnemonic} A new Mnemonic instance.
+     */
+    public static fromString(str: string): Mnemonic {
+        return new this().fromString(str)
+    }
+
+    /**
+     * Converts the instance's mnemonic to a string representation.
+     * @returns {string} The mnemonic phrase as a string.
+     */
+    public toString(): string {
+        return this.mnemonic
+    }
+
+    /**
+     * Converts the mnemonic to a seed.
+     * The mnemonic must pass the validity check before conversion.
+     * @param {string} [passphrase=''] - An optional passphrase for additional security.
+     * @returns {number[]} The generated seed.
+     * @throws {Error} If the mnemonic is invalid.
+     */
+    public toSeed(passphrase?: string): number[] {
+        this.mnemonic2Seed(passphrase)
+        return this.seed
+    }
+
+    /**
+     * Converts entropy to a mnemonic phrase.
+     * This method takes a buffer of entropy and converts it into a corresponding
+     * mnemonic phrase based on the Mnemonic wordlist. The entropy should be at least 128 bits.
+     * The method applies a checksum and maps the entropy to words in the wordlist.
+     * @param {number[]} buf - The entropy buffer to convert. Must be at least 128 bits.
+     * @returns {this} The Mnemonic instance with the mnemonic set from the entropy.
+     * @throws {Error} If the entropy is less than 128 bits or if it's not an even multiple of 11 bits.
+     */
+    public entropy2Mnemonic(buf: number[]): this {
+        if (buf.length < 128 / 8) {
+            throw new Error('Entropy is less than 128 bits. It must be 128 bits or more.')
+        }
+
+        const hash = Hash.sha256(buf)
+        let bin = ''
+        const bits = buf.length * 8
+        for (let i = 0; i < buf.length; i++) {
+            bin = bin + ('00000000' + buf[i].toString(2)).slice(-8)
+        }
+        let hashbits = hash[0].toString(2)
+        hashbits = ('00000000' + hashbits).slice(-8).slice(0, bits / 32)
+        bin = bin + hashbits
+
+        if (bin.length % 11 !== 0) {
+            throw new Error('internal error - entropy not an even multiple of 11 bits - ' + bin.length)
+        }
+
+        let mnemonic = ''
+        for (let i = 0; i < bin.length / 11; i++) {
+            if (mnemonic !== '') {
+                mnemonic = mnemonic + this.Wordlist.space
+            }
+            const wi = parseInt(bin.slice(i * 11, (i + 1) * 11), 2)
+            mnemonic = mnemonic + this.Wordlist.value[wi]
+        }
+
+        this.mnemonic = mnemonic
+        return this
+    }
+
+    /**
+     * Validates the mnemonic phrase.
+     * Checks for correct length, absence of invalid words, and proper checksum.
+     * @returns {boolean} True if the mnemonic is valid, false otherwise.
+     * @throws {Error} If the mnemonic is not an even multiple of 11 bits.
+     */
+    public check(): boolean {
+        const mnemonic = this.mnemonic
+
+        // confirm no invalid words
+        const words = mnemonic.split(this.Wordlist.space)
+        let bin = ''
+        for (let i = 0; i < words.length; i++) {
+            const ind = this.Wordlist.value.indexOf(words[i])
+            if (ind < 0) {
+                return false
+            }
+            bin = bin + ('00000000000' + ind.toString(2)).slice(-11)
+        }
+
+        if (bin.length % 11 !== 0) {
+            throw new Error('internal error - entropy not an even multiple of 11 bits - ' + bin.length)
+        }
+
+        // confirm checksum
+        const cs = bin.length / 33
+        const hashBits = bin.slice(-cs)
+        const nonhashBits = bin.slice(0, bin.length - cs)
+        const buf = []
+        for (let i = 0; i < nonhashBits.length / 8; i++) {
+            buf.push(parseInt(bin.slice(i * 8, (i + 1) * 8), 2))
+        }
+        const hash = Hash.sha256(buf.slice(0, nonhashBits.length / 8))
+        let expectedHashBits = hash[0].toString(2)
+        expectedHashBits = ('00000000' + expectedHashBits).slice(-8).slice(0, cs)
+
+        return expectedHashBits === hashBits
+    }
+
+    /**
+     * Converts a mnemonic to a seed.
+     * This method takes the instance's mnemonic phrase, combines it with a passphrase (if provided),
+     * and uses PBKDF2 to generate a seed. It also validates the mnemonic before conversion.
+     * This seed can then be used for generating deterministic keys.
+     * @param {string} [passphrase=''] - An optional passphrase for added security.
+     * @returns {this} The Mnemonic instance with the seed generated from the mnemonic.
+     * @throws {Error} If the mnemonic does not pass validation or if the passphrase is not a string.
+     */
+    public mnemonic2Seed(passphrase = ''): this {
+        let mnemonic = this.mnemonic
+        if (!this.check()) {
+            throw new Error(
+                'Mnemonic does not pass the check - was the mnemonic typed incorrectly? Are there extra spaces?'
+            )
+        }
+        if (typeof passphrase !== 'string') {
+            throw new Error('passphrase must be a string or undefined')
+        }
+        mnemonic = mnemonic.normalize('NFKD')
+        passphrase = passphrase.normalize('NFKD')
+        const mbuf = toArray(mnemonic, 'utf8')
+        const pbuf = [...toArray('mnemonic', 'utf8'), ...toArray(passphrase, 'utf8')]
+        this.seed = Hash.pbkdf2(mbuf, pbuf, 2048, 64, 'sha512')
+        return this
+    }
+
+    /**
+     * Determines the validity of a given passphrase with the mnemonic.
+     * This method is useful for checking if a passphrase matches with the mnemonic.
+     * @param {string} [passphrase=''] - The passphrase to validate.
+     * @returns {boolean} True if the mnemonic and passphrase combination is valid, false otherwise.
+     */
+    public isValid(passphrase = ''): boolean {
+        let isValid
+        try {
+            isValid = !!this.mnemonic2Seed(passphrase)
+        } catch (err) {
+            isValid = false
+        }
+        return isValid
+    }
+
+    /**
+     * Static method to check the validity of a given mnemonic and passphrase combination.
+     * @param {string} mnemonic - The mnemonic phrase.
+     * @param {string} [passphrase=''] - The passphrase to validate.
+     * @returns {boolean} True if the combination is valid, false otherwise.
+     */
+    public static isValid(mnemonic: string, passphrase = ''): boolean {
+        return new Mnemonic(mnemonic).isValid(passphrase)
+    }
+}

package/src/compat/__tests/BSM.test.ts

@@ -0,0 +1,38 @@
+import { sign, verify, magicHash } from '../../../dist/cjs/src/compat/BSM'
+import { toArray } from '../../../dist/cjs/src/primitives/utils'
+import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey'
+import PublicKey from '../../../dist/cjs/src/primitives/PublicKey'
+import Signature from '../../../dist/cjs/src/primitives/Signature'
+
+describe('BSM', () => {
+    describe('magicHash', () => {
+        it('should return a hash', () => {
+            const buf = toArray('001122', 'hex')
+            const hashBuf = magicHash(buf)
+            expect(hashBuf.length).toEqual(32)
+        })
+    })
+    describe('sign', () => {
+        const messageBuf = toArray('this is my message', 'utf8')
+        const privateKey = new PrivateKey(42)
+        it('should return a signature', () => {
+            const sig = sign(messageBuf, privateKey).toDER()
+            expect(sig.length).toEqual(70)
+        })
+    })
+    describe('verify', () => {
+        const messageBuf = toArray('this is my message', 'utf8')
+        const privateKey = new PrivateKey(42)
+
+        it('should verify a signed message', () => {
+            const sig = sign(messageBuf, privateKey)
+            expect(verify(messageBuf, sig, privateKey.toPublicKey())).toEqual(true)
+        })
+        it('Should verify a signed message in base64', () => {
+            const message = toArray("Texas", 'utf8')
+            const signature = Signature.fromDER("IAV89EkfHSzAIA8cEWbbKHUYzJqcShkpWaXGJ5+mf4+YIlf3XNlr0bj9X60sNe1A7+x9qyk+zmXropMDY4370n8=", 'base64')
+            const publicKey = PublicKey.fromString("03d4d1a6c5d8c03b0e671bc1891b69afaecb40c0686188fe9019f93581b43e8334")
+            expect(verify(message, signature, publicKey)).toBe(true)
+        })
+    })
+})