@atomicfinance/bitcoin-dlc-provider 4.0.0 → 4.0.2

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

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * 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 declare function ccpEncrypt(k: Buffer, n: Buffer, ad: Buffer, plaintext: Buffer): Buffer;
+/**
+ * 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 declare function ccpDecrypt(k: Buffer, n: Buffer, ad: Buffer, ciphertext: Buffer): Buffer;

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

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ccpDecrypt = exports.ccpEncrypt = void 0;
+const crypto_1 = __importDefault(require("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
+ */
+function ccpEncrypt(k, n, ad, plaintext) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const cipher = crypto_1.default.createCipheriv('ChaCha20-Poly1305', k, n, {
+        authTagLength: 16,
+    });
+    cipher.setAAD(ad, undefined);
+    const pad = cipher.update(plaintext);
+    cipher.final();
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([pad, tag]);
+}
+exports.ccpEncrypt = ccpEncrypt;
+/**
+ * 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
+ */
+function ccpDecrypt(k, n, ad, ciphertext) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const decipher = crypto_1.default.createDecipheriv('ChaCha20-Poly1305', 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;
+    }
+}
+exports.ccpDecrypt = ccpDecrypt;
+//# sourceMappingURL=chachapoly.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chachapoly.js","sourceRoot":"","sources":["../lib/chachapoly.ts"],"names":[],"mappings":";;;;;;AAAA,oDAA4B;AAE5B;;;;;;;;;GASG;AACH,SAAgB,UAAU,CACxB,CAAS,EACT,CAAS,EACT,EAAU,EACV,SAAiB;IAEjB,8DAA8D;IAC9D,MAAM,MAAM,GAAG,gBAAM,CAAC,cAAc,CAAC,mBAA0B,EAAE,CAAC,EAAE,CAAC,EAAE;QACrE,aAAa,EAAE,EAAE;KAClB,CAAC,CAAC;IACH,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;IAC7B,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IACrC,MAAM,CAAC,KAAK,EAAE,CAAC;IACf,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC;IAChC,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AACnC,CAAC;AAfD,gCAeC;AAED;;;;;;;;;GASG;AACH,SAAgB,UAAU,CACxB,CAAS,EACT,CAAS,EACT,EAAU,EACV,UAAkB;IAElB,8DAA8D;IAC9D,MAAM,QAAQ,GAAG,gBAAM,CAAC,gBAAgB,CAAC,mBAA0B,EAAE,CAAC,EAAE,CAAC,EAAE;QACzE,aAAa,EAAE,EAAE;KAClB,CAAC,CAAC;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;IAE/B,IAAI,UAAU,CAAC,MAAM,KAAK,EAAE,EAAE;QAC5B,QAAQ,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;QAChC,OAAO,QAAQ,CAAC,KAAK,EAAE,CAAC;KACzB;IACD,IAAI,UAAU,CAAC,MAAM,GAAG,EAAE,EAAE;QAC1B,MAAM,GAAG,GAAG,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;QACrD,MAAM,GAAG,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;QACxD,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QACzB,IAAI,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC7B,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,EAAE,CAAC;QAC3B,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC1B,OAAO,CAAC,CAAC;KACV;AACH,CAAC;AAzBD,gCAyBC"}

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

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * Hash using SHA256
+ *
+ * @param data data to hash
+ * @returns 32-byte digest
+ */
+export declare function sha256(data: Buffer): Buffer;
+/**
+ * Hash using RIPEM160
+ * @param data data to hash, any length
+ * @returns 20-byte digest
+ */
+export declare function ripemd160(data: Buffer): Buffer;
+/**
+ * Hash using ripmd160 and sha256
+ *
+ * @param data data to hash, any length
+ * @returns 20-byte digest
+ */
+export declare function hash160(data: Buffer): Buffer;
+/**
+ * Performs double sha256 hash
+ *
+ * @param data data to hash, any length
+ * @returns 32-byte digest
+ */
+export declare function hash256(data: Buffer): Buffer;

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

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash256 = exports.hash160 = exports.ripemd160 = exports.sha256 = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * Hash using SHA256
+ *
+ * @param data data to hash
+ * @returns 32-byte digest
+ */
+function sha256(data) {
+    const hash = crypto_1.default.createHash('sha256');
+    hash.update(data);
+    return hash.digest();
+}
+exports.sha256 = sha256;
+/**
+ * Hash using RIPEM160
+ * @param data data to hash, any length
+ * @returns 20-byte digest
+ */
+function ripemd160(data) {
+    const hash = crypto_1.default.createHash('ripemd160');
+    hash.update(data);
+    return hash.digest();
+}
+exports.ripemd160 = ripemd160;
+/**
+ * Hash using ripmd160 and sha256
+ *
+ * @param data data to hash, any length
+ * @returns 20-byte digest
+ */
+function hash160(data) {
+    return ripemd160(sha256(data));
+}
+exports.hash160 = hash160;
+/**
+ * Performs double sha256 hash
+ *
+ * @param data data to hash, any length
+ * @returns 32-byte digest
+ */
+function hash256(data) {
+    return sha256(sha256(data));
+}
+exports.hash256 = hash256;
+//# sourceMappingURL=hash.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","sourceRoot":"","sources":["../lib/hash.ts"],"names":[],"mappings":";;;;;;AAAA,oDAA4B;AAE5B;;;;;GAKG;AACH,SAAgB,MAAM,CAAC,IAAY;IACjC,MAAM,IAAI,GAAG,gBAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IACzC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAClB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;AACvB,CAAC;AAJD,wBAIC;AAED;;;;GAIG;AACH,SAAgB,SAAS,CAAC,IAAY;IACpC,MAAM,IAAI,GAAG,gBAAM,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IAC5C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAClB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;AACvB,CAAC;AAJD,8BAIC;AAED;;;;;GAKG;AACH,SAAgB,OAAO,CAAC,IAAY;IAClC,OAAO,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AACjC,CAAC;AAFD,0BAEC;AAED;;;;;GAKG;AACH,SAAgB,OAAO,CAAC,IAAY;IAClC,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAC9B,CAAC;AAFD,0BAEC"}

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

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * 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 declare function hkdf(ikm: Buffer, len: number, salt?: Buffer, info?: Buffer, hash?: string): Buffer;

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

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hkdf = void 0;
+const crypto_1 = __importDefault(require("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
+ */
+function hkdf(ikm, len, salt = Buffer.alloc(0), info = Buffer.alloc(0), hash = 'sha256') {
+    // 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);
+}
+exports.hkdf = hkdf;
+function hmacHash(key, input, hash) {
+    const hmac = crypto_1.default.createHmac(hash, key);
+    hmac.update(input);
+    return hmac.digest();
+}
+//# sourceMappingURL=hkdf.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hkdf.js","sourceRoot":"","sources":["../lib/hkdf.ts"],"names":[],"mappings":";;;;;;AAAA,oDAA4B;AAE5B;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,IAAI,CAClB,GAAW,EACX,GAAW,EACX,OAAe,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAC9B,OAAe,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAC9B,IAAI,GAAG,QAAQ;IAEf,eAAe;IACf,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IAEtC,SAAS;IACT,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC;IAE1C,uDAAuD;IACvD,uDAAuD;IACvD,8DAA8D;IAC9D,mEAAmE;IACnE,IAAI,CAAC,GAAG,GAAG;QAAE,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;IAE9D,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;QAC3B,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC3B,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5B,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;KAC5D;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AACjD,CAAC;AA1BD,oBA0BC;AAED,SAAS,QAAQ,CAAC,GAAW,EAAE,KAAa,EAAE,IAAY;IACxD,MAAM,IAAI,GAAG,gBAAM,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAC1C,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACnB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;AACvB,CAAC"}

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

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export declare function hmac(key: Buffer, data: Buffer, algorithm?: string): Buffer;

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

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hmac = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+function hmac(key, data, algorithm = 'sha256') {
+    const h = crypto_1.default.createHmac(algorithm, key);
+    h.update(data);
+    return h.digest();
+}
+exports.hmac = hmac;
+//# sourceMappingURL=hmac.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.js","sourceRoot":"","sources":["../lib/hmac.ts"],"names":[],"mappings":";;;;;;AAAA,oDAA4B;AAE5B,SAAgB,IAAI,CAAC,GAAW,EAAE,IAAY,EAAE,SAAS,GAAG,QAAQ;IAClE,MAAM,CAAC,GAAG,gBAAM,CAAC,UAAU,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;IAC5C,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACf,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC;AACpB,CAAC;AAJD,oBAIC"}

package/.yalc/@node-dlc/crypto/dist/index.d.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/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sigFromDER = void 0;
+__exportStar(require("./aes"), exports);
+__exportStar(require("./aes-key"), exports);
+__exportStar(require("./chacha"), exports);
+__exportStar(require("./chachapoly"), exports);
+__exportStar(require("./hash"), exports);
+__exportStar(require("./hkdf"), exports);
+__exportStar(require("./hmac"), exports);
+__exportStar(require("./key"), exports);
+__exportStar(require("./secp256k1"), exports);
+var secp256k1_1 = require("./secp256k1");
+Object.defineProperty(exports, "sigFromDER", { enumerable: true, get: function () { return secp256k1_1.sigFromDER; } });
+__exportStar(require("./xor"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,wCAAsB;AACtB,4CAA0B;AAC1B,2CAAyB;AACzB,+CAA6B;AAC7B,yCAAuB;AACvB,yCAAuB;AACvB,yCAAuB;AACvB,wCAAsB;AACtB,8CAA4B;AAC5B,yCAAyC;AAAhC,uGAAA,UAAU,OAAA;AACnB,wCAAsB"}

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

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * 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 declare function validPrivateKey(privKey: Buffer): boolean;
+/**
+ * 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 declare function validPublicKey(pubkey: Buffer): boolean;
+/**
+ * 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 declare function createPrivateKey(): Buffer;
+/**
+ * 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 declare function getPublicKey(privKey: Buffer, compressed?: boolean): Buffer;

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

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublicKey = exports.createPrivateKey = exports.validPublicKey = exports.validPrivateKey = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const secp256k1_1 = __importDefault(require("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
+ */
+function validPrivateKey(privKey) {
+    try {
+        return secp256k1_1.default.privateKeyVerify(privKey);
+    }
+    catch (ex) {
+        return false;
+    }
+}
+exports.validPrivateKey = validPrivateKey;
+/**
+ * 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
+ */
+function validPublicKey(pubkey) {
+    try {
+        return secp256k1_1.default.publicKeyVerify(pubkey);
+    }
+    catch (ex) {
+        return false;
+    }
+}
+exports.validPublicKey = validPublicKey;
+/**
+ * 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
+ */
+function createPrivateKey() {
+    let result;
+    do {
+        result = crypto_1.default.randomBytes(32);
+    } while (!validPrivateKey(result));
+    return result;
+}
+exports.createPrivateKey = createPrivateKey;
+/**
+ * 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
+ */
+function getPublicKey(privKey, compressed = true) {
+    return Buffer.from(secp256k1_1.default.publicKeyCreate(privKey, compressed));
+}
+exports.getPublicKey = getPublicKey;
+//# sourceMappingURL=key.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"key.js","sourceRoot":"","sources":["../lib/key.ts"],"names":[],"mappings":";;;;;;AAAA,oDAA4B;AAC5B,0DAAkC;AAElC,wCAAwC;AACxC,sGAAsG;AAEtG;;;;;;GAMG;AACH,SAAgB,eAAe,CAAC,OAAe;IAC7C,IAAI;QACF,OAAO,mBAAS,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;KAC5C;IAAC,OAAO,EAAE,EAAE;QACX,OAAO,KAAK,CAAC;KACd;AACH,CAAC;AAND,0CAMC;AAED;;;;;GAKG;AACH,SAAgB,cAAc,CAAC,MAAc;IAC3C,IAAI;QACF,OAAO,mBAAS,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;KAC1C;IAAC,OAAO,EAAE,EAAE;QACX,OAAO,KAAK,CAAC;KACd;AACH,CAAC;AAND,wCAMC;AAED;;;;;;;;;GASG;AACH,SAAgB,gBAAgB;IAC9B,IAAI,MAAc,CAAC;IACnB,GAAG;QACD,MAAM,GAAG,gBAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;KACjC,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,EAAE;IACnC,OAAO,MAAM,CAAC;AAChB,CAAC;AAND,4CAMC;AAED;;;;;;;GAOG;AACH,SAAgB,YAAY,CAAC,OAAe,EAAE,UAAU,GAAG,IAAI;IAC7D,OAAO,MAAM,CAAC,IAAI,CAAC,mBAAS,CAAC,eAAe,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC;AACrE,CAAC;AAFD,oCAEC"}

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

@@ -0,0 +1,120 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * 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
+ */
+export declare function ecdh(publicKey: Buffer, privateKey: Buffer): Buffer;
+/**
+ * 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
+ */
+export declare function privateKeyMul(secret: Buffer, tweak: Buffer): Buffer;
+/**
+ * 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
+ */
+export declare function sign(msg: Buffer, privateKey: Buffer): Buffer;
+/**
+ * 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
+ */
+export declare function signWithRecovery(msg: Buffer, privateKey: Buffer): {
+    signature: Buffer;
+    recovery: number;
+};
+/**
+ * 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)
+ */
+export declare function sigToDER(sig: Buffer): Buffer;
+/**
+ * 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
+ */
+export declare function verifySig(msg: Buffer, sig: Buffer, pubkey: Buffer): boolean;
+/**
+ * Returns true if the signature is a DER encoded signature
+ * @param sig a DER encoded signature
+ */
+export declare function isDERSig(sig: Buffer): boolean;
+/**
+ * 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
+ */
+export declare function sigFromDER(derSig: Buffer): Buffer;
+/**
+ * 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
+ */
+export declare function recoverPubKey(signature: Buffer, recovery: number, message: Buffer, compressed?: boolean): Buffer;
+/**
+ * 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
+ */
+export declare function publicKeyTweakAdd(publicKey: Buffer, tweak: Buffer, compressed?: boolean): Buffer;
+/**
+ * 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
+ */
+export declare function publicKeyTweakMul(publicKey: Buffer, tweak: Buffer, compressed?: boolean): Buffer;
+/**
+ * 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
+ */
+export declare function publicKeyCombine(pubkeys: Buffer[], compressed?: boolean): Buffer;
+/**
+ * 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
+ */
+export declare function privateKeyTweakAdd(privateKey: Buffer, tweak: Buffer): Buffer;
+/**
+ * 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
+ */
+export declare function privateKeyTweakMul(privateKey: Buffer, tweak: Buffer): Buffer;