@atomicfinance/bitcoin-dlc-provider 4.1.0 → 4.1.1

package/.yalc/@node-dlc/crypto/dist/secp256k1.js

@@ -1,184 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.privateKeyTweakMul = exports.privateKeyTweakAdd = exports.publicKeyCombine = exports.publicKeyTweakMul = exports.publicKeyTweakAdd = exports.recoverPubKey = exports.sigFromDER = exports.isDERSig = exports.verifySig = exports.sigToDER = exports.signWithRecovery = exports.sign = exports.privateKeyMul = exports.ecdh = void 0;
-const secp256k1_1 = __importDefault(require("secp256k1"));
-/**
- * Elliptic Curve Diffie-Helman on secp256k1 takes a
- * public key and point multiplies it by the private key.
- * The resulting compressed public key value is hashed via
- * sha256.
- *
- * @param publicKey 33-byte compressed public key
- * @param privateKey  32-byte private key
- * @returns 32-byte sha256 of the point multiple
- */
-function ecdh(publicKey, privateKey) {
-    return Buffer.from(secp256k1_1.default.ecdh(publicKey, privateKey));
-}
-exports.ecdh = ecdh;
-/**
- * Performs modular multiplication on the secret value by multiplying by the
- * tweak value
- * @param secret 32-byte secret
- * @param tweak 32-byte tweak
- * @returns 32-byte secret
- */
-function privateKeyMul(secret, tweak) {
-    return Buffer.from(secp256k1_1.default.privateKeyTweakMul(Buffer.from(secret), tweak));
-}
-exports.privateKeyMul = privateKeyMul;
-/**
- * Create an ECDSA signature for the 32-byte message using the private
- * key. This method returns the normalized low-s version of the signature
- * as a 64-byte Buffer (r,s) values.
- * @param msg 32-byte message
- * @param privateKey 32-byte secp256k1 private key
- * @returns signatures as 64-byte buffer with (r,s) pair
- */
-function sign(msg, privateKey) {
-    const { signature } = secp256k1_1.default.ecdsaSign(msg, privateKey);
-    secp256k1_1.default.signatureNormalize(signature);
-    return Buffer.from(signature);
-}
-exports.sign = sign;
-/**
- * Create an ECDSA signature for the 32-byte message using the private
- * key. This method returns both the signature in the normalized low-s
- * version of the signature as a 64-bte Buffer (r,s) and the recovery
- * identifier.
- * @param msg 32-byte message
- * @param privateKey 32-byte secp256k1 private key
- */
-function signWithRecovery(msg, privateKey) {
-    const { signature, recid } = secp256k1_1.default.ecdsaSign(msg, privateKey);
-    return {
-        signature: Buffer.from(signature),
-        recovery: recid,
-    };
-}
-exports.signWithRecovery = signWithRecovery;
-/**
- * Encodes a signature into a DER encoding. This encoding is 8-73 bytes
- * in length depending on the length of the s value in the signature.
- * @param sig 64-byte buffer containing (r, s)
- */
-function sigToDER(sig) {
-    return Buffer.from(secp256k1_1.default.signatureExport(sig));
-}
-exports.sigToDER = sigToDER;
-/**
- * Verifies an ECDSA signature and returns true or false
- * if the signatures is valid.
- *
- * @param msg 32-byte message (256 hash or message)
- * @param sig 64-byte
- * @param pubkey 33-byte compressed pubkey
- * @returns true when signature is valid
- */
-function verifySig(msg, sig, pubkey) {
-    return secp256k1_1.default.ecdsaVerify(sig, msg, pubkey);
-}
-exports.verifySig = verifySig;
-/**
- * Returns true if the signature is a DER encoded signature
- * @param sig a DER encoded signature
- */
-function isDERSig(sig) {
-    try {
-        secp256k1_1.default.signatureImport(sig);
-        return true;
-    }
-    catch (ex) {
-        return false;
-    }
-}
-exports.isDERSig = isDERSig;
-/**
- * Parses a DER-encoded signature and returns the raw 64-byte signature (r,s)
- * @param derSig DER-encoded signature buffer
- * @returns 64-byte buffer containing raw (r,s) signature
- */
-function sigFromDER(derSig) {
-    try {
-        const rawSig = secp256k1_1.default.signatureImport(derSig);
-        return Buffer.from(rawSig);
-    }
-    catch (ex) {
-        throw new Error(`Invalid DER signature: ${ex.message}`);
-    }
-}
-exports.sigFromDER = sigFromDER;
-/**
- * Recovers the public key from the signature and recovery identifier
- * for the signed message.
- * @param signature 64-byte signature
- * @param recovery recovery id
- * @param message message that was signed
- * @param compressed whether the pubkey is compressed
- */
-function recoverPubKey(signature, recovery, message, compressed = true) {
-    const result = secp256k1_1.default.ecdsaRecover(signature, recovery, message, compressed);
-    return Buffer.from(result);
-}
-exports.recoverPubKey = recoverPubKey;
-/**
- * Tweaks a public key by adding tweak * G to the point. The equation is
- * T = P + t*G
- *
- * @param publicKey 33-byte or 65-byte public key
- * @param tweak 32-byte scalar value that is multiplied by G
- * @param compressed true to compress the resulting point
- * @returns the 33-byte compressed or 65-byte uncompressed public key point
- */
-function publicKeyTweakAdd(publicKey, tweak, compressed = true) {
-    return Buffer.from(secp256k1_1.default.publicKeyTweakAdd(publicKey, tweak, compressed));
-}
-exports.publicKeyTweakAdd = publicKeyTweakAdd;
-/**
- * Tweaks a public key by multiplying it against a scalar. The equation is
- * T = P * t
- *
- * @param publicKey 33-byte or 65-byte public key
- * @param tweak 32-byte tweak to multiply against the public key
- * @param compressed true to compress the resulting point
- * @returns the 33-byte compressed or 65-byte uncompressed public key point
- */
-function publicKeyTweakMul(publicKey, tweak, compressed = true) {
-    return Buffer.from(secp256k1_1.default.publicKeyTweakMul(publicKey, tweak, compressed));
-}
-exports.publicKeyTweakMul = publicKeyTweakMul;
-/**
- * Performs point addition
- *
- * @param pubkeys list of 33-byte or 65-byte public keys
- * @param compressed true to compress the resulting point
- * @returns the 33-byte compressed or 65-byte uncompressed public key point
- */
-function publicKeyCombine(pubkeys, compressed = true) {
-    return Buffer.from(secp256k1_1.default.publicKeyCombine(pubkeys, compressed));
-}
-exports.publicKeyCombine = publicKeyCombine;
-/**
- * Tweaks a private key by adding a value to it. The question is: e + t.
- *
- * @param privateKey the 32-byte private key
- * @param tweak a 32-byte tweak
- */
-function privateKeyTweakAdd(privateKey, tweak) {
-    return Buffer.from(secp256k1_1.default.privateKeyTweakAdd(Buffer.from(privateKey), tweak));
-}
-exports.privateKeyTweakAdd = privateKeyTweakAdd;
-/**
- * Tweaks a private key by multiplying it. The equation is: e * t.
- *
- * @param privateKey the 32-byte private key
- * @param tweak a 32-byte tweak
- */
-function privateKeyTweakMul(privateKey, tweak) {
-    return Buffer.from(secp256k1_1.default.privateKeyTweakMul(Buffer.from(privateKey), tweak));
-}
-exports.privateKeyTweakMul = privateKeyTweakMul;
-//# sourceMappingURL=secp256k1.js.map

package/.yalc/@node-dlc/crypto/dist/secp256k1.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"secp256k1.js","sourceRoot":"","sources":["../lib/secp256k1.ts"],"names":[],"mappings":";;;;;;AAAA,0DAAkC;AAElC;;;;;;;;;GASG;AACH,SAAgB,IAAI,CAAC,SAAiB,EAAE,UAAkB;IACxD,OAAO,MAAM,CAAC,IAAI,CAAC,mBAAS,CAAC,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;AAC5D,CAAC;AAFD,oBAEC;AAED;;;;;;GAMG;AACH,SAAgB,aAAa,CAAC,MAAc,EAAE,KAAa;IACzD,OAAO,MAAM,CAAC,IAAI,CAAC,mBAAS,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AAC/E,CAAC;AAFD,sCAEC;AAED;;;;;;;GAOG;AACH,SAAgB,IAAI,CAAC,GAAW,EAAE,UAAkB;IAClD,MAAM,EAAE,SAAS,EAAE,GAAG,mBAAS,CAAC,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;IAC3D,mBAAS,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;IACxC,OAAO,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAChC,CAAC;AAJD,oBAIC;AAED;;;;;;;GAOG;AACH,SAAgB,gBAAgB,CAC9B,GAAW,EACX,UAAkB;IAElB,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,mBAAS,CAAC,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;IAClE,OAAO;QACL,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC;QACjC,QAAQ,EAAE,KAAK;KAChB,CAAC;AACJ,CAAC;AATD,4CASC;AAED;;;;GAIG;AACH,SAAgB,QAAQ,CAAC,GAAW;IAClC,OAAO,MAAM,CAAC,IAAI,CAAC,mBAAS,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC;AACrD,CAAC;AAFD,4BAEC;AAED;;;;;;;;GAQG;AACH,SAAgB,SAAS,CAAC,GAAW,EAAE,GAAW,EAAE,MAAc;IAChE,OAAO,mBAAS,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;AACjD,CAAC;AAFD,8BAEC;AAED;;;GAGG;AACH,SAAgB,QAAQ,CAAC,GAAW;IAClC,IAAI;QACF,mBAAS,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;QAC/B,OAAO,IAAI,CAAC;KACb;IAAC,OAAO,EAAE,EAAE;QACX,OAAO,KAAK,CAAC;KACd;AACH,CAAC;AAPD,4BAOC;AAED;;;;GAIG;AACH,SAAgB,UAAU,CAAC,MAAc;IACvC,IAAI;QACF,MAAM,MAAM,GAAG,mBAAS,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;QACjD,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;KAC5B;IAAC,OAAO,EAAE,EAAE;QACX,MAAM,IAAI,KAAK,CAAC,0BAA0B,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;KACzD;AACH,CAAC;AAPD,gCAOC;AAED;;;;;;;GAOG;AACH,SAAgB,aAAa,CAC3B,SAAiB,EACjB,QAAgB,EAChB,OAAe,EACf,UAAU,GAAG,IAAI;IAEjB,MAAM,MAAM,GAAG,mBAAS,CAAC,YAAY,CACnC,SAAS,EACT,QAAQ,EACR,OAAO,EACP,UAAU,CACX,CAAC;IACF,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC7B,CAAC;AAbD,sCAaC;AAED;;;;;;;;GAQG;AACH,SAAgB,iBAAiB,CAC/B,SAAiB,EACjB,KAAa,EACb,UAAU,GAAG,IAAI;IAEjB,OAAO,MAAM,CAAC,IAAI,CAAC,mBAAS,CAAC,iBAAiB,CAAC,SAAS,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC;AAChF,CAAC;AAND,8CAMC;AAED;;;;;;;;GAQG;AACH,SAAgB,iBAAiB,CAC/B,SAAiB,EACjB,KAAa,EACb,UAAU,GAAG,IAAI;IAEjB,OAAO,MAAM,CAAC,IAAI,CAAC,mBAAS,CAAC,iBAAiB,CAAC,SAAS,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC;AAChF,CAAC;AAND,8CAMC;AAED;;;;;;GAMG;AACH,SAAgB,gBAAgB,CAAC,OAAiB,EAAE,UAAU,GAAG,IAAI;IACnE,OAAO,MAAM,CAAC,IAAI,CAAC,mBAAS,CAAC,gBAAgB,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC;AACtE,CAAC;AAFD,4CAEC;AAED;;;;;GAKG;AACH,SAAgB,kBAAkB,CAAC,UAAkB,EAAE,KAAa;IAClE,OAAO,MAAM,CAAC,IAAI,CAChB,mBAAS,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC,CAC7D,CAAC;AACJ,CAAC;AAJD,gDAIC;AAED;;;;;GAKG;AACH,SAAgB,kBAAkB,CAAC,UAAkB,EAAE,KAAa;IAClE,OAAO,MAAM,CAAC,IAAI,CAChB,mBAAS,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC,CAC7D,CAAC;AACJ,CAAC;AAJD,gDAIC"}

package/.yalc/@node-dlc/crypto/dist/xor.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/**
- * Performs XOR of the two buffers where only the min length will be XOR'd
- * @param a
- * @param b
- */
-export declare function xor(a: Buffer, b: Buffer): Buffer;

package/.yalc/@node-dlc/crypto/dist/xor.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.xor = void 0;
-/**
- * Performs XOR of the two buffers where only the min length will be XOR'd
- * @param a
- * @param b
- */
-function xor(a, b) {
-    const result = Buffer.alloc(Math.min(a.length, b.length));
-    for (let i = 0; i < result.length; i++) {
-        result[i] = a[i] ^ b[i];
-    }
-    return result;
-}
-exports.xor = xor;
-//# sourceMappingURL=xor.js.map

package/.yalc/@node-dlc/crypto/dist/xor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"xor.js","sourceRoot":"","sources":["../lib/xor.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACH,SAAgB,GAAG,CAAC,CAAS,EAAE,CAAS;IACtC,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACtC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;KACzB;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAND,kBAMC"}

package/.yalc/@node-dlc/crypto/lib/aes-key.ts

@@ -1,4 +0,0 @@
-export type AesKey = {
-  salt: Buffer;
-  key: Buffer;
-};

package/.yalc/@node-dlc/crypto/lib/aes.ts

@@ -1,81 +0,0 @@
-import crypto from 'crypto';
-
-import { AesKey } from './aes-key';
-
-/**
- * Encrypts data using AES-256-CBC
- * @param key symmetric key (must be 32 bytes for AES-256)
- * @param buffer plaintext to encrypt
- * @returns encrypted buffer with IV prepended
- */
-export function aesEncrypt({
-  key,
-  buffer,
-}: {
-  key: Buffer;
-  buffer: Buffer;
-}): Buffer {
-  // Generate a random IV
-  const iv = crypto.randomBytes(16);
-
-  // Ensure key is 32 bytes for AES-256
-  const keyHash = crypto.createHash('sha256').update(key).digest();
-
-  const cipher = crypto.createCipheriv('aes-256-cbc', keyHash, iv);
-  let encrypted = cipher.update(buffer);
-  encrypted = Buffer.concat([encrypted, cipher.final()]);
-
-  // Prepend IV to the encrypted data
-  return Buffer.concat([iv, encrypted]);
-}
-
-/**
- * Decrypts data using AES-256-CBC.
- * @param key symmetric key
- * @param buffer ciphertext to decrypt (with IV prepended)
- */
-export function aesDecrypt({
-  key,
-  buffer,
-}: {
-  key: Buffer;
-  buffer: Buffer;
-}): Buffer {
-  // Extract IV from the beginning of the buffer
-  const iv = buffer.slice(0, 16);
-  const encrypted = buffer.slice(16);
-
-  // Ensure key is 32 bytes for AES-256
-  const keyHash = crypto.createHash('sha256').update(key).digest();
-
-  const decipher = crypto.createDecipheriv('aes-256-cbc', keyHash, iv);
-  let decrypted = decipher.update(encrypted);
-  decrypted = Buffer.concat([decrypted, decipher.final()]);
-
-  return decrypted;
-}
-
-/**
- * Generate a a secure key from the passphrase and salt
- * by performing PBKDF2. If no salt is provided one is
- * generated via randomBytes.
- *
- * @param passphrase
- * @param [salt] 16-byte buffer or more
- */
-export function createAesKey({
-  passphrase,
-  salt,
-}: {
-  passphrase: string;
-  salt?: Buffer;
-}): AesKey {
-  if (!salt) {
-    salt = crypto.randomBytes(16);
-  }
-  const key = crypto.pbkdf2Sync(passphrase, salt, 100000, 128, 'sha512');
-  return {
-    key,
-    salt,
-  };
-}

package/.yalc/@node-dlc/crypto/lib/chacha.ts

@@ -1,13 +0,0 @@
-import * as crypto from 'crypto';
-
-export function chachaEncrypt(key: Buffer, iv: Buffer, data: Buffer): Buffer {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const cipher = crypto.createCipheriv('chacha20' as any, key, iv);
-  return cipher.update(data);
-}
-
-export function chachaDecrypt(key: Buffer, iv: Buffer, cipher: Buffer): Buffer {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const decipher = crypto.createDecipheriv('chacha20' as any, key, iv);
-  return decipher.update(cipher);
-}

package/.yalc/@node-dlc/crypto/lib/chachapoly.ts

@@ -1,65 +0,0 @@
-import crypto from 'crypto';
-
-/**
- * Encrypt data using authenticated encryption with associated data (AEAD)
- * ChaCha20-Poly1305.
- *
- * @param k private key, 64-bytes
- * @param n nonce, 12-bytes
- * @param ad associated data
- * @param plaintext raw data to encrypt
- * @returns encrypted data + tag as a variable length buffer
- */
-export function ccpEncrypt(
-  k: Buffer,
-  n: Buffer,
-  ad: Buffer,
-  plaintext: Buffer,
-): Buffer {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const cipher = crypto.createCipheriv('ChaCha20-Poly1305' as any, k, n, {
-    authTagLength: 16,
-  });
-  cipher.setAAD(ad, undefined);
-  const pad = cipher.update(plaintext);
-  cipher.final();
-  const tag = cipher.getAuthTag();
-  return Buffer.concat([pad, tag]);
-}
-
-/**
- * Decrypt data uusing authenticated encryption with associated data (AEAD)
- * ChaCha20-Poly1305
- *
- * @param k private key, 64-bytes
- * @param n nonce, 12-bytes
- * @param ad associated data, variable length
- * @param ciphertext encrypted data to decrypt
- * @returns decrypteed data as a variable length Buffer
- */
-export function ccpDecrypt(
-  k: Buffer,
-  n: Buffer,
-  ad: Buffer,
-  ciphertext: Buffer,
-): Buffer {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const decipher = crypto.createDecipheriv('ChaCha20-Poly1305' as any, k, n, {
-    authTagLength: 16,
-  });
-  decipher.setAAD(ad, undefined);
-
-  if (ciphertext.length === 16) {
-    decipher.setAuthTag(ciphertext);
-    return decipher.final();
-  }
-  if (ciphertext.length > 16) {
-    const tag = ciphertext.slice(ciphertext.length - 16);
-    const pad = ciphertext.slice(0, ciphertext.length - 16);
-    decipher.setAuthTag(tag);
-    let m = decipher.update(pad);
-    const f = decipher.final();
-    m = Buffer.concat([m, f]);
-    return m;
-  }
-}

package/.yalc/@node-dlc/crypto/lib/hash.ts

@@ -1,44 +0,0 @@
-import crypto from 'crypto';
-
-/**
- * Hash using SHA256
- *
- * @param data data to hash
- * @returns 32-byte digest
- */
-export function sha256(data: Buffer): Buffer {
-  const hash = crypto.createHash('sha256');
-  hash.update(data);
-  return hash.digest();
-}
-
-/**
- * Hash using RIPEM160
- * @param data data to hash, any length
- * @returns 20-byte digest
- */
-export function ripemd160(data: Buffer): Buffer {
-  const hash = crypto.createHash('ripemd160');
-  hash.update(data);
-  return hash.digest();
-}
-
-/**
- * Hash using ripmd160 and sha256
- *
- * @param data data to hash, any length
- * @returns 20-byte digest
- */
-export function hash160(data: Buffer): Buffer {
-  return ripemd160(sha256(data));
-}
-
-/**
- * Performs double sha256 hash
- *
- * @param data data to hash, any length
- * @returns 32-byte digest
- */
-export function hash256(data: Buffer): Buffer {
-  return sha256(sha256(data));
-}

package/.yalc/@node-dlc/crypto/lib/hkdf.ts

@@ -1,52 +0,0 @@
-import crypto from 'crypto';
-
-/**
- * HMAC-based Extact and Expand Key Derivation Function (HKDF)
- * that complies with RFC 5869.
- *
- * @remarks
- * Refer to https://tools.ietf.org/html/rfc5869 for detailed information.
- *
- * The current implementation only supports up to 254 expansion rounds for
- * a total of 255 rounds.
- *
- * @param ikm initial key material, variable length
- * @param len output key material length
- * @param salt optional, defaults to none
- * @param info optional, defaults to none
- * @param hash optional, defaults to sha256
- * @returns output key material of specified length
- */
-export function hkdf(
-  ikm: Buffer,
-  len: number,
-  salt: Buffer = Buffer.alloc(0),
-  info: Buffer = Buffer.alloc(0),
-  hash = 'sha256',
-): Buffer {
-  // extract step
-  const prk = hmacHash(salt, ikm, hash);
-
-  // expand
-  const n = Math.ceil(len / prk.byteLength);
-
-  // validate we don't overflow iteration counter buffer.
-  // Note that we can support larger values but will need
-  // to modify how the integer byte is constructed, additionally
-  // the specification does not specify the endianness of the counter
-  if (n > 255) throw new Error('Output length exceeds maximum');
-
-  const t = [Buffer.alloc(0)];
-  for (let i = 1; i <= n; i++) {
-    const tp = t[t.length - 1];
-    const bi = Buffer.from([i]);
-    t.push(hmacHash(prk, Buffer.concat([tp, info, bi]), hash));
-  }
-  return Buffer.concat(t.slice(1)).slice(0, len);
-}
-
-function hmacHash(key: Buffer, input: Buffer, hash: string) {
-  const hmac = crypto.createHmac(hash, key);
-  hmac.update(input);
-  return hmac.digest();
-}

package/.yalc/@node-dlc/crypto/lib/hmac.ts

@@ -1,7 +0,0 @@
-import crypto from 'crypto';
-
-export function hmac(key: Buffer, data: Buffer, algorithm = 'sha256'): Buffer {
-  const h = crypto.createHmac(algorithm, key);
-  h.update(data);
-  return h.digest();
-}

package/.yalc/@node-dlc/crypto/lib/index.ts

@@ -1,11 +0,0 @@
-export * from './aes';
-export * from './aes-key';
-export * from './chacha';
-export * from './chachapoly';
-export * from './hash';
-export * from './hkdf';
-export * from './hmac';
-export * from './key';
-export * from './secp256k1';
-export { sigFromDER } from './secp256k1';
-export * from './xor';

package/.yalc/@node-dlc/crypto/lib/key.ts

@@ -1,64 +0,0 @@
-import crypto from 'crypto';
-import secp256k1 from 'secp256k1';
-
-// const minPrivateKey = BigInt("0x01");
-// const maxPrivateKey = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140");
-
-/**
- * Returns true when the Buffer represents a 256-bit number that is between
- * 0x1 and 0xffffffffffffffffffffffffffffffffbaaedce6af48a03bbfd25e8cd0364140
- * as documented in https://en.bitcoin.it/wiki/Private_key
- *
- * @param privKey 32-byte/256-bit buffer
- */
-export function validPrivateKey(privKey: Buffer): boolean {
-  try {
-    return secp256k1.privateKeyVerify(privKey);
-  } catch (ex) {
-    return false;
-  }
-}
-
-/**
- * Returns true when the Buffer represents a valid SEC encoded public
- * key stored in a buffer. This expects the prefix and length to be
- * correct.
- * @param pubkey
- */
-export function validPublicKey(pubkey: Buffer): boolean {
-  try {
-    return secp256k1.publicKeyVerify(pubkey);
-  } catch (ex) {
-    return false;
-  }
-}
-
-/**
- * Generates a cryptographially secure 256-bit private key
- * that is valid for elliptic curve secp256k1
- *
- * @remarks This method uses crypto.randomBytes to
- * generate the random value. It may be better to use a
- * HRBG
- *
- * @returns the 32-byte/256-bit private key
- */
-export function createPrivateKey(): Buffer {
-  let result: Buffer;
-  do {
-    result = crypto.randomBytes(32);
-  } while (!validPrivateKey(result));
-  return result;
-}
-
-/**
- * Gets the public key in the ellitic curve secp256k1
- * from the provided private key
- *
- * @param privKey 32-byte/256-bit private key
- * @returns 33-byte buffer for compressed,
- * 65-byte buffer for uncompressed
- */
-export function getPublicKey(privKey: Buffer, compressed = true): Buffer {
-  return Buffer.from(secp256k1.publicKeyCreate(privKey, compressed));
-}