@atomiqlabs/sdk 8.9.1 → 8.9.3

package/dist/intermediaries/auth/SignedKeyBasedAuth.js

@@ -1,68 +1,68 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSignedKeyBasedAuthHandler = void 0;
-const secp256k1_1 = require("@noble/curves/secp256k1");
-const Utils_1 = require("../../utils/Utils");
-function parsePrivateKey(value, name) {
-    if (!/^[0-9a-fA-F]{64}$/.test(value))
-        throw new Error(`${name} must be a 32-byte hex private key`);
-    const bytes = Buffer.from(value, "hex");
-    if (!secp256k1_1.secp256k1.utils.isValidPrivateKey(bytes))
-        throw new Error(`${name} is not a valid secp256k1 private key`);
-    return bytes;
-}
-function parsePublicKey(value, name) {
-    if (!/^[0-9a-fA-F]{64}$/.test(value))
-        throw new Error(`${name} must be an X-only 32-byte hex public key`);
-    if (!secp256k1_1.secp256k1.utils.isValidPublicKey(Buffer.from("02" + value, "hex"), true))
-        throw new Error(`${name} is not a valid X-only 32-byte secp256k1 public key`);
-    return Buffer.from(value, "hex");
-}
-function parseSignature(value, name) {
-    if (!/^[0-9a-fA-F]{128}$/.test(value))
-        throw new Error(`${name} must be a valid 64-byte hex schnorr signature`);
-    return Buffer.from(value, "hex");
-}
-const CERTIFICATE_LENGTH = 64 + 128 + 64;
-/**
- * Adds a `x-atomiq-auth` header with the following binary format, that is hex-encoded:
- * - 4 bytes - timestamp (timestamp when the request was sent)
- * - 32 bytes - random bytes (entropy, to be signed)
- *
- * - 32 bytes - key of the signing authority
- * - 64 bytes - schnorr signature signing the request signing key by the signing authority
- *
- * - 32 bytes - request signing key (signed by the signing authority)
- * - 64 bytes - schnorr signature of the timestamp and random bytes
- *
- * Uses secp256k1 curve and schnorr signatures
- */
-function getSignedKeyBasedAuthHandler(certificate, privateKey) {
-    const _privateKey = parsePrivateKey(privateKey, "Private key");
-    if (certificate.length !== CERTIFICATE_LENGTH)
-        throw new Error(`Certificate has invalid length, expected ${CERTIFICATE_LENGTH}!`);
-    const authorityPublicKey = parsePublicKey(certificate.substring(0, 64), "Certificate: Authority Public key");
-    const authoritySignature = parseSignature(certificate.substring(64, 64 + 128), "Certificate: Authority Signature");
-    const signingPublicKey = parsePublicKey(certificate.substring(64 + 128), "Certificate: Signing Public key");
-    if (!secp256k1_1.schnorr.verify(authoritySignature, signingPublicKey, authorityPublicKey))
-        throw new Error("Invalid certificate, authority signature is not valid!");
-    if (!signingPublicKey.equals(secp256k1_1.schnorr.getPublicKey(privateKey)))
-        throw new Error("Passed private key doesn't match the certificate!");
-    const _certificate = Buffer.from(certificate, "hex");
-    return () => {
-        const timestamp = Math.floor(Date.now() / 1000);
-        const timestampBuffer = Buffer.alloc(4);
-        timestampBuffer.writeUInt32BE(timestamp);
-        const requestUid = (0, Utils_1.randomBytes)(32);
-        const toSign = Buffer.concat([timestampBuffer, requestUid]);
-        const signature = secp256k1_1.schnorr.sign(toSign, _privateKey);
-        return {
-            "x-atomiq-auth": Buffer.concat([
-                toSign,
-                _certificate,
-                signature
-            ]).toString("hex")
-        };
-    };
-}
-exports.getSignedKeyBasedAuthHandler = getSignedKeyBasedAuthHandler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSignedKeyBasedAuthHandler = void 0;
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const Utils_1 = require("../../utils/Utils");
+function parsePrivateKey(value, name) {
+    if (!/^[0-9a-fA-F]{64}$/.test(value))
+        throw new Error(`${name} must be a 32-byte hex private key`);
+    const bytes = Buffer.from(value, "hex");
+    if (!secp256k1_1.secp256k1.utils.isValidPrivateKey(bytes))
+        throw new Error(`${name} is not a valid secp256k1 private key`);
+    return bytes;
+}
+function parsePublicKey(value, name) {
+    if (!/^[0-9a-fA-F]{64}$/.test(value))
+        throw new Error(`${name} must be an X-only 32-byte hex public key`);
+    if (!secp256k1_1.secp256k1.utils.isValidPublicKey(Buffer.from("02" + value, "hex"), true))
+        throw new Error(`${name} is not a valid X-only 32-byte secp256k1 public key`);
+    return Buffer.from(value, "hex");
+}
+function parseSignature(value, name) {
+    if (!/^[0-9a-fA-F]{128}$/.test(value))
+        throw new Error(`${name} must be a valid 64-byte hex schnorr signature`);
+    return Buffer.from(value, "hex");
+}
+const CERTIFICATE_LENGTH = 64 + 128 + 64;
+/**
+ * Adds a `x-atomiq-auth` header with the following binary format, that is hex-encoded:
+ * - 4 bytes - timestamp (timestamp when the request was sent)
+ * - 32 bytes - random bytes (entropy, to be signed)
+ *
+ * - 32 bytes - key of the signing authority
+ * - 64 bytes - schnorr signature signing the request signing key by the signing authority
+ *
+ * - 32 bytes - request signing key (signed by the signing authority)
+ * - 64 bytes - schnorr signature of the timestamp and random bytes
+ *
+ * Uses secp256k1 curve and schnorr signatures
+ */
+function getSignedKeyBasedAuthHandler(certificate, privateKey) {
+    const _privateKey = parsePrivateKey(privateKey, "Private key");
+    if (certificate.length !== CERTIFICATE_LENGTH)
+        throw new Error(`Certificate has invalid length, expected ${CERTIFICATE_LENGTH}!`);
+    const authorityPublicKey = parsePublicKey(certificate.substring(0, 64), "Certificate: Authority Public key");
+    const authoritySignature = parseSignature(certificate.substring(64, 64 + 128), "Certificate: Authority Signature");
+    const signingPublicKey = parsePublicKey(certificate.substring(64 + 128), "Certificate: Signing Public key");
+    if (!secp256k1_1.schnorr.verify(authoritySignature, signingPublicKey, authorityPublicKey))
+        throw new Error("Invalid certificate, authority signature is not valid!");
+    if (!signingPublicKey.equals(secp256k1_1.schnorr.getPublicKey(privateKey)))
+        throw new Error("Passed private key doesn't match the certificate!");
+    const _certificate = Buffer.from(certificate, "hex");
+    return () => {
+        const timestamp = Math.floor(Date.now() / 1000);
+        const timestampBuffer = Buffer.alloc(4);
+        timestampBuffer.writeUInt32BE(timestamp);
+        const requestUid = (0, Utils_1.randomBytes)(32);
+        const toSign = Buffer.concat([timestampBuffer, requestUid]);
+        const signature = secp256k1_1.schnorr.sign(toSign, _privateKey);
+        return {
+            "x-atomiq-auth": Buffer.concat([
+                toSign,
+                _certificate,
+                signature
+            ]).toString("hex")
+        };
+    };
+}
+exports.getSignedKeyBasedAuthHandler = getSignedKeyBasedAuthHandler;

package/dist/lnurl/LNURL.d.ts

@@ -1,102 +1,102 @@
-import { PaymentRequestObject, TagsObject } from "@atomiqlabs/bolt11";
-import { LNURLWithdraw, LNURLWithdrawParamsWithUrl } from "../types/lnurl/LNURLWithdraw";
-import { LNURLDecodedSuccessAction, LNURLPay, LNURLPayParamsWithUrl } from "../types/lnurl/LNURLPay";
-export type LNURLPaySuccessAction = {
-    tag: string;
-    description: string | null;
-    url: string | null;
-    message: string | null;
-    ciphertext: string | null;
-    iv: string | null;
-};
-export declare function isLNURLPaySuccessAction(obj: any, domain?: string): obj is LNURLPaySuccessAction;
-/**
- * LNURL encoding/decoding and callback handling
- * @category Bitcoin
- */
-export declare class LNURL {
-    private static findBech32LNURL;
-    private static isBech32LNURL;
-    /**
-     * Checks whether a provided string is bare (non bech32 encoded) lnurl
-     * @param str
-     * @private
-     */
-    private static isBareLNURL;
-    /**
-     * Checks if the provided string is a lightning network address (e.g. satoshi@nakamoto.com)
-     * @param str
-     * @private
-     */
-    private static isLightningAddress;
-    /**
-     * Checks whether a given string is a LNURL or lightning address
-     * @param str
-     */
-    static isLNURL(str: string): boolean;
-    /**
-     * Extracts the URL that needs to be request from LNURL or lightning address
-     * @param str
-     * @private
-     * @returns An URL to send the request to, or null if it cannot be parsed
-     */
-    private static extractCallUrl;
-    /**
-     * Sends a request to obtain data about a specific LNURL or lightning address
-     *
-     * @param str A lnurl or lightning address
-     * @param shouldRetry Whether we should retry in case of network failure
-     * @param timeout Request timeout in milliseconds
-     * @param abortSignal
-     */
-    static getLNURL(str: string, shouldRetry?: boolean, timeout?: number, abortSignal?: AbortSignal): Promise<LNURLPayParamsWithUrl | LNURLWithdrawParamsWithUrl | null>;
-    /**
-     * Sends a request to obtain data about a specific LNURL or lightning address
-     *
-     * @param str A lnurl or lightning address
-     * @param shouldRetry Whether we should retry in case of network failure
-     * @param timeout Request timeout in milliseconds
-     * @param abortSignal
-     */
-    static getLNURLType(str: string, shouldRetry?: boolean, timeout?: number, abortSignal?: AbortSignal): Promise<LNURLPay | LNURLWithdraw | null>;
-    /**
-     * Uses a LNURL-pay request by obtaining a lightning network invoice from it
-     *
-     * @param payRequest LNURL params as returned from the getLNURL call
-     * @param amount Amount of sats (BTC) to pay
-     * @param comment Optional comment for the payment request
-     * @param timeout Request timeout in milliseconds
-     * @param abortSignal
-     * @throws {RequestError} If the response is non-200, status: ERROR, or invalid format
-     */
-    static useLNURLPay(payRequest: LNURLPayParamsWithUrl, amount: bigint, comment?: string, timeout?: number, abortSignal?: AbortSignal): Promise<{
-        invoice: string;
-        parsedInvoice: PaymentRequestObject & {
-            tagsObject: TagsObject;
-        };
-        successAction?: LNURLPaySuccessAction;
-    }>;
-    /**
-     * Submits the bolt11 lightning invoice to the lnurl withdraw url
-     *
-     * @param withdrawRequest Withdraw request to use
-     * @param withdrawRequest.k1 K1 parameter
-     * @param withdrawRequest.callback A URL to call
-     * @param lnpr bolt11 lightning network invoice to submit to the withdrawal endpoint
-     * @throws {RequestError} If the response is non-200 or status: ERROR
-     */
-    static postInvoiceToLNURLWithdraw(withdrawRequest: {
-        k1: string;
-        callback: string;
-    }, lnpr: string): Promise<void>;
-    /**
-     * Uses a LNURL-withdraw request by submitting a lightning network invoice to it
-     *
-     * @param withdrawRequest Withdrawal request as returned from getLNURL call
-     * @param lnpr bolt11 lightning network invoice to submit to the withdrawal endpoint
-     * @throws {UserError} In case the provided bolt11 lightning invoice has an amount that is out of bounds for
-     *  the specified LNURL-withdraw request
-     */
-    static useLNURLWithdraw(withdrawRequest: LNURLWithdrawParamsWithUrl, lnpr: string): Promise<void>;
-    static decodeSuccessAction(successAction?: LNURLPaySuccessAction | null, secret?: string | null): LNURLDecodedSuccessAction | null;
-}
+import { PaymentRequestObject, TagsObject } from "@atomiqlabs/bolt11";
+import { LNURLWithdraw, LNURLWithdrawParamsWithUrl } from "../types/lnurl/LNURLWithdraw";
+import { LNURLDecodedSuccessAction, LNURLPay, LNURLPayParamsWithUrl } from "../types/lnurl/LNURLPay";
+export type LNURLPaySuccessAction = {
+    tag: string;
+    description: string | null;
+    url: string | null;
+    message: string | null;
+    ciphertext: string | null;
+    iv: string | null;
+};
+export declare function isLNURLPaySuccessAction(obj: any, domain?: string): obj is LNURLPaySuccessAction;
+/**
+ * LNURL encoding/decoding and callback handling
+ * @category Bitcoin
+ */
+export declare class LNURL {
+    private static findBech32LNURL;
+    private static isBech32LNURL;
+    /**
+     * Checks whether a provided string is bare (non bech32 encoded) lnurl
+     * @param str
+     * @private
+     */
+    private static isBareLNURL;
+    /**
+     * Checks if the provided string is a lightning network address (e.g. satoshi@nakamoto.com)
+     * @param str
+     * @private
+     */
+    private static isLightningAddress;
+    /**
+     * Checks whether a given string is a LNURL or lightning address
+     * @param str
+     */
+    static isLNURL(str: string): boolean;
+    /**
+     * Extracts the URL that needs to be request from LNURL or lightning address
+     * @param str
+     * @private
+     * @returns An URL to send the request to, or null if it cannot be parsed
+     */
+    private static extractCallUrl;
+    /**
+     * Sends a request to obtain data about a specific LNURL or lightning address
+     *
+     * @param str A lnurl or lightning address
+     * @param shouldRetry Whether we should retry in case of network failure
+     * @param timeout Request timeout in milliseconds
+     * @param abortSignal
+     */
+    static getLNURL(str: string, shouldRetry?: boolean, timeout?: number, abortSignal?: AbortSignal): Promise<LNURLPayParamsWithUrl | LNURLWithdrawParamsWithUrl | null>;
+    /**
+     * Sends a request to obtain data about a specific LNURL or lightning address
+     *
+     * @param str A lnurl or lightning address
+     * @param shouldRetry Whether we should retry in case of network failure
+     * @param timeout Request timeout in milliseconds
+     * @param abortSignal
+     */
+    static getLNURLType(str: string, shouldRetry?: boolean, timeout?: number, abortSignal?: AbortSignal): Promise<LNURLPay | LNURLWithdraw | null>;
+    /**
+     * Uses a LNURL-pay request by obtaining a lightning network invoice from it
+     *
+     * @param payRequest LNURL params as returned from the getLNURL call
+     * @param amount Amount of sats (BTC) to pay
+     * @param comment Optional comment for the payment request
+     * @param timeout Request timeout in milliseconds
+     * @param abortSignal
+     * @throws {RequestError} If the response is non-200, status: ERROR, or invalid format
+     */
+    static useLNURLPay(payRequest: LNURLPayParamsWithUrl, amount: bigint, comment?: string, timeout?: number, abortSignal?: AbortSignal): Promise<{
+        invoice: string;
+        parsedInvoice: PaymentRequestObject & {
+            tagsObject: TagsObject;
+        };
+        successAction?: LNURLPaySuccessAction;
+    }>;
+    /**
+     * Submits the bolt11 lightning invoice to the lnurl withdraw url
+     *
+     * @param withdrawRequest Withdraw request to use
+     * @param withdrawRequest.k1 K1 parameter
+     * @param withdrawRequest.callback A URL to call
+     * @param lnpr bolt11 lightning network invoice to submit to the withdrawal endpoint
+     * @throws {RequestError} If the response is non-200 or status: ERROR
+     */
+    static postInvoiceToLNURLWithdraw(withdrawRequest: {
+        k1: string;
+        callback: string;
+    }, lnpr: string): Promise<void>;
+    /**
+     * Uses a LNURL-withdraw request by submitting a lightning network invoice to it
+     *
+     * @param withdrawRequest Withdrawal request as returned from getLNURL call
+     * @param lnpr bolt11 lightning network invoice to submit to the withdrawal endpoint
+     * @throws {UserError} In case the provided bolt11 lightning invoice has an amount that is out of bounds for
+     *  the specified LNURL-withdraw request
+     */
+    static useLNURLWithdraw(withdrawRequest: LNURLWithdrawParamsWithUrl, lnpr: string): Promise<void>;
+    static decodeSuccessAction(successAction?: LNURLPaySuccessAction | null, secret?: string | null): LNURLDecodedSuccessAction | null;
+}