@atomicfinance/bitcoin-dlc-provider 4.0.0 → 4.0.1

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

@@ -0,0 +1,184 @@
+"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

@@ -0,0 +1 @@
+{"version":3,"file":"secp256k1.js","sourceRoot":"","sources":["../lib/secp256k1.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,8 @@
+/// <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

@@ -0,0 +1,17 @@
+"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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,64 @@
+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));
+}