@atomiqlabs/sdk 8.8.3 → 8.8.4

package/src/types/lnurl/LNURLWithdraw.ts

@@ -1,61 +1,61 @@
-/**
- * Response of the LNURL-withdraw link
- *
- * @category Lightning
- */
-export type LNURLWithdrawParams = {
-    tag: "withdrawRequest";
-    k1: string;
-    callback: string;
-    domain: string;
-    minWithdrawable: number;
-    maxWithdrawable: number;
-    defaultDescription: string;
-    balanceCheck?: string;
-    payLink?: string;
-}
-
-/**
- * Response of the LNURL-withdraw link with the added original url
- *
- * @category Lightning
- */
-export type LNURLWithdrawParamsWithUrl = LNURLWithdrawParams & { url: string };
-
-/**
- * Parsed LNURL-withdraw specification
- *
- * @category Lightning
- */
-export type LNURLWithdraw = {
-    type: "withdraw",
-    min: bigint,
-    max: bigint,
-    params: LNURLWithdrawParamsWithUrl
-}
-
-/**
- * Type guard for {@link LNURLWithdraw}
- *
- * @category Lightning
- */
-export function isLNURLWithdraw(value: any): value is LNURLWithdraw {
-    return (
-        typeof value === "object" &&
-        value != null &&
-        value.type === "withdraw" &&
-        typeof (value.min) === "bigint" &&
-        typeof (value.max) === "bigint" &&
-        isLNURLWithdrawParams(value.params)
-    );
-}
-
-/**
- * Type guard for {@link LNURLWithdrawParams}
- *
- * @category Lightning
- * @internal
- */
-export function isLNURLWithdrawParams(obj: any): obj is LNURLWithdrawParams {
-    return obj.tag === "withdrawRequest";
-}
+/**
+ * Response of the LNURL-withdraw link
+ *
+ * @category Lightning
+ */
+export type LNURLWithdrawParams = {
+    tag: "withdrawRequest";
+    k1: string;
+    callback: string;
+    domain: string;
+    minWithdrawable: number;
+    maxWithdrawable: number;
+    defaultDescription: string;
+    balanceCheck?: string;
+    payLink?: string;
+}
+
+/**
+ * Response of the LNURL-withdraw link with the added original url
+ *
+ * @category Lightning
+ */
+export type LNURLWithdrawParamsWithUrl = LNURLWithdrawParams & { url: string };
+
+/**
+ * Parsed LNURL-withdraw specification
+ *
+ * @category Lightning
+ */
+export type LNURLWithdraw = {
+    type: "withdraw",
+    min: bigint,
+    max: bigint,
+    params: LNURLWithdrawParamsWithUrl
+}
+
+/**
+ * Type guard for {@link LNURLWithdraw}
+ *
+ * @category Lightning
+ */
+export function isLNURLWithdraw(value: any): value is LNURLWithdraw {
+    return (
+        typeof value === "object" &&
+        value != null &&
+        value.type === "withdraw" &&
+        typeof (value.min) === "bigint" &&
+        typeof (value.max) === "bigint" &&
+        isLNURLWithdrawParams(value.params)
+    );
+}
+
+/**
+ * Type guard for {@link LNURLWithdrawParams}
+ *
+ * @category Lightning
+ * @internal
+ */
+export function isLNURLWithdrawParams(obj: any): obj is LNURLWithdrawParams {
+    return obj.tag === "withdrawRequest";
+}

package/src/types/wallets/LightningInvoiceCreateService.ts

@@ -1,30 +1,30 @@
-/**
- * Invoice getter callback for the {@link LightningInvoiceCreateService}
- *
- * @category Lightning
- */
-export type LightningWalletCallback = (valueSats: number, abortSignal?: AbortSignal) => Promise<string>;
-/**
- * Service that creates on-demand fixed amount bolt11 lightning network invoices, optionally
- *  specifying minimum and maximum swappable sats amount. This used for exact input Smart chain ->
- *  Lightning swaps.
- *
- * @category Lightning
- */
-export type LightningInvoiceCreateService = {
-    getInvoice: LightningWalletCallback,
-    minMsats?: bigint,
-    maxMSats?: bigint
-};
-
-/**
- * Type guard for {@link LightningInvoiceCreateService}
- *
- * @internal
- */
-export function isLightningInvoiceCreateService(obj: any): obj is LightningInvoiceCreateService {
-    return typeof (obj) === "object" &&
-        typeof (obj.getInvoice) === "function" &&
-        (obj.minMsats == null || typeof (obj.minMsats) === "bigint") &&
-        (obj.maxMSats == null || typeof (obj.maxMSats) === "bigint");
-}
+/**
+ * Invoice getter callback for the {@link LightningInvoiceCreateService}
+ *
+ * @category Lightning
+ */
+export type LightningWalletCallback = (valueSats: number, abortSignal?: AbortSignal) => Promise<string>;
+/**
+ * Service that creates on-demand fixed amount bolt11 lightning network invoices, optionally
+ *  specifying minimum and maximum swappable sats amount. This used for exact input Smart chain ->
+ *  Lightning swaps.
+ *
+ * @category Lightning
+ */
+export type LightningInvoiceCreateService = {
+    getInvoice: LightningWalletCallback,
+    minMsats?: bigint,
+    maxMSats?: bigint
+};
+
+/**
+ * Type guard for {@link LightningInvoiceCreateService}
+ *
+ * @internal
+ */
+export function isLightningInvoiceCreateService(obj: any): obj is LightningInvoiceCreateService {
+    return typeof (obj) === "object" &&
+        typeof (obj.getInvoice) === "function" &&
+        (obj.minMsats == null || typeof (obj.minMsats) === "bigint") &&
+        (obj.maxMSats == null || typeof (obj.maxMSats) === "bigint");
+}

package/src/types/wallets/MinimalBitcoinWalletInterface.ts

@@ -1,21 +1,21 @@
-import {Transaction} from "@scure/btc-signer";
-
-/**
- * A type with minimum possible required data about a bitcoin wallet to be able to estimate fees and produce unsigned
- *  funded PSBTs with address's UTXOs
- *
- * @category Bitcoin
- */
-export type MinimalBitcoinWalletInterface = {
-    address: string,
-    publicKey: string
-};
-
-/**
- * A type with minimum possible required data about a bitcoin wallet to be able to estimate fees and sign PSBTs
- *
- * @category Bitcoin
- */
-export type MinimalBitcoinWalletInterfaceWithSigner = MinimalBitcoinWalletInterface & {
-    signPsbt: (psbtToSign: {psbt: Transaction, psbtHex: string, psbtBase64: string}, signInputs: number[]) => Promise<Transaction | string>
-};
+import {Transaction} from "@scure/btc-signer";
+
+/**
+ * A type with minimum possible required data about a bitcoin wallet to be able to estimate fees and produce unsigned
+ *  funded PSBTs with address's UTXOs
+ *
+ * @category Bitcoin
+ */
+export type MinimalBitcoinWalletInterface = {
+    address: string,
+    publicKey: string
+};
+
+/**
+ * A type with minimum possible required data about a bitcoin wallet to be able to estimate fees and sign PSBTs
+ *
+ * @category Bitcoin
+ */
+export type MinimalBitcoinWalletInterfaceWithSigner = MinimalBitcoinWalletInterface & {
+    signPsbt: (psbtToSign: {psbt: Transaction, psbtHex: string, psbtBase64: string}, signInputs: number[]) => Promise<Transaction | string>
+};

package/src/types/wallets/MinimalLightningNetworkWalletInterface.ts

@@ -1,9 +1,9 @@
-/**
- * A type with minimum possible required functionality to be usable with lightning network swaps, i.e.
- *  a function to pay bolt11 lightning network invoices.
- *
- * @category Lightning
- */
-export type MinimalLightningNetworkWalletInterface = {
-    payInvoice: (bolt11PaymentRequest: string) => Promise<string>
-}
+/**
+ * A type with minimum possible required functionality to be usable with lightning network swaps, i.e.
+ *  a function to pay bolt11 lightning network invoices.
+ *
+ * @category Lightning
+ */
+export type MinimalLightningNetworkWalletInterface = {
+    payInvoice: (bolt11PaymentRequest: string) => Promise<string>
+}

package/src/utils/AutomaticClockDriftCorrection.ts

@@ -1,71 +1,71 @@
-import {timeoutSignal} from "./TimeoutUtils";
-
-const headerUrls = ["https://api.atomiq.exchange/"];
-
-type TimeReturnType = {delta: number, timestamp: number};
-
-async function getHeaderTimestamp(url: string): Promise<TimeReturnType> {
-    const timeStart = performance.now();
-    const resp = await fetch(url, {method: "HEAD", signal: timeoutSignal(3000)});
-    const timeDelta = performance.now() - timeStart;
-    const dateHeaderValue = resp.headers.get("Date");
-    if(dateHeaderValue==null) throw new Error("Date header not returned!");
-    return {delta: timeDelta, timestamp: new Date(dateHeaderValue).getTime()};
-}
-
-async function getBinanceTimestamp(): Promise<TimeReturnType> {
-    const timeStart = performance.now();
-    const resp = await fetch("https://api.binance.com/api/v3/time", {signal: timeoutSignal(3000)});
-    const timeDelta = performance.now() - timeStart;
-    const obj: {serverTime: number} = await resp.json();
-    if(obj==null || obj.serverTime==null) throw new Error("Timestamp not returned!");
-    return {delta: timeDelta, timestamp: Math.floor(obj.serverTime)};
-}
-
-async function getOKXTimestamp(): Promise<TimeReturnType> {
-    const timeStart = performance.now();
-    const resp = await fetch("https://www.okx.com/api/v5/public/time", {signal: timeoutSignal(3000)});
-    const timeDelta = performance.now() - timeStart;
-    const obj: {code: number, msg: string, data: [{ts: number}]} = await resp.json();
-    if(obj==null || obj.data==null || obj.data[0]==null || obj.data[0].ts==null) throw new Error("Timestamp not returned!");
-    return {delta: timeDelta, timestamp: Math.floor(obj.data[0].ts)};
-}
-
-async function getAisenseApiTimestamp(): Promise<TimeReturnType> {
-    const timeStart = performance.now();
-    const resp = await fetch("https://aisenseapi.com/services/v1/timestamp", {signal: timeoutSignal(3000)});
-    const timeDelta = performance.now() - timeStart;
-    const obj = await resp.json();
-    if(obj==null || obj.timestamp==null) throw new Error("Timestamp not returned!");
-    return {delta: timeDelta, timestamp: Math.floor(obj.timestamp * 1000)};
-}
-
-export async function correctClock() {
-    const dateNow: () => number = (Date as any)._now ?? Date.now;
-    const dateStart = performance.now();
-
-    try {
-        let result: TimeReturnType = await Promise.any([
-            ...headerUrls.map(url => getHeaderTimestamp(url)),
-            getAisenseApiTimestamp(),
-            getBinanceTimestamp(),
-            getOKXTimestamp()
-        ]);
-
-        const desiredTime = result.timestamp - (result.delta / 2);
-        if(Math.abs(Date.now() - desiredTime) < 2000) {
-            console.log("AutomaticClockDriftCorrection: correctClock(): Time drift too small, not adjusting!");
-            return;
-        }
-
-        const timeDrift = dateStart - desiredTime;
-        console.log(`AutomaticClockDriftCorrection: correctClock(): Time correction perf.now: ${dateStart}, server: ${desiredTime}, time diff: ${timeDrift}`);
-        (Date as any)._now = dateNow;
-        (Date as any).now = () => {
-            return Math.floor(performance.now() - timeDrift);
-        };
-    } catch (e: any) {
-        if(e instanceof AggregateError) e.message = "Cannot sync time! All servers responded negatively!";
-        throw e;
-    }
-}
+import {timeoutSignal} from "./TimeoutUtils";
+
+const headerUrls = ["https://api.atomiq.exchange/"];
+
+type TimeReturnType = {delta: number, timestamp: number};
+
+async function getHeaderTimestamp(url: string): Promise<TimeReturnType> {
+    const timeStart = performance.now();
+    const resp = await fetch(url, {method: "HEAD", signal: timeoutSignal(3000)});
+    const timeDelta = performance.now() - timeStart;
+    const dateHeaderValue = resp.headers.get("Date");
+    if(dateHeaderValue==null) throw new Error("Date header not returned!");
+    return {delta: timeDelta, timestamp: new Date(dateHeaderValue).getTime()};
+}
+
+async function getBinanceTimestamp(): Promise<TimeReturnType> {
+    const timeStart = performance.now();
+    const resp = await fetch("https://api.binance.com/api/v3/time", {signal: timeoutSignal(3000)});
+    const timeDelta = performance.now() - timeStart;
+    const obj: {serverTime: number} = await resp.json();
+    if(obj==null || obj.serverTime==null) throw new Error("Timestamp not returned!");
+    return {delta: timeDelta, timestamp: Math.floor(obj.serverTime)};
+}
+
+async function getOKXTimestamp(): Promise<TimeReturnType> {
+    const timeStart = performance.now();
+    const resp = await fetch("https://www.okx.com/api/v5/public/time", {signal: timeoutSignal(3000)});
+    const timeDelta = performance.now() - timeStart;
+    const obj: {code: number, msg: string, data: [{ts: number}]} = await resp.json();
+    if(obj==null || obj.data==null || obj.data[0]==null || obj.data[0].ts==null) throw new Error("Timestamp not returned!");
+    return {delta: timeDelta, timestamp: Math.floor(obj.data[0].ts)};
+}
+
+async function getAisenseApiTimestamp(): Promise<TimeReturnType> {
+    const timeStart = performance.now();
+    const resp = await fetch("https://aisenseapi.com/services/v1/timestamp", {signal: timeoutSignal(3000)});
+    const timeDelta = performance.now() - timeStart;
+    const obj = await resp.json();
+    if(obj==null || obj.timestamp==null) throw new Error("Timestamp not returned!");
+    return {delta: timeDelta, timestamp: Math.floor(obj.timestamp * 1000)};
+}
+
+export async function correctClock() {
+    const dateNow: () => number = (Date as any)._now ?? Date.now;
+    const dateStart = performance.now();
+
+    try {
+        let result: TimeReturnType = await Promise.any([
+            ...headerUrls.map(url => getHeaderTimestamp(url)),
+            getAisenseApiTimestamp(),
+            getBinanceTimestamp(),
+            getOKXTimestamp()
+        ]);
+
+        const desiredTime = result.timestamp - (result.delta / 2);
+        if(Math.abs(Date.now() - desiredTime) < 2000) {
+            console.log("AutomaticClockDriftCorrection: correctClock(): Time drift too small, not adjusting!");
+            return;
+        }
+
+        const timeDrift = dateStart - desiredTime;
+        console.log(`AutomaticClockDriftCorrection: correctClock(): Time correction perf.now: ${dateStart}, server: ${desiredTime}, time diff: ${timeDrift}`);
+        (Date as any)._now = dateNow;
+        (Date as any).now = () => {
+            return Math.floor(performance.now() - timeDrift);
+        };
+    } catch (e: any) {
+        if(e instanceof AggregateError) e.message = "Cannot sync time! All servers responded negatively!";
+        throw e;
+    }
+}

package/src/utils/BitcoinUtils.ts

@@ -1,132 +1,132 @@
-import {BTC_NETWORK, isBytes, PubT, validatePubkey} from "@scure/btc-signer/utils";
-import {Buffer} from "buffer";
-import {Address, OutScript, Transaction} from "@scure/btc-signer";
-import {CoinselectAddressTypes} from "../bitcoin/coinselect2";
-import { randomBytes } from "./Utils";
-
-
-export function fromOutputScript(network: BTC_NETWORK, outputScriptHex: string): string {
-    return Address(network).encode(OutScript.decode(Buffer.from(outputScriptHex, "hex")));
-}
-
-export function toOutputScript(network: BTC_NETWORK, address: string): Buffer {
-    const outputScript = Address(network).decode(address);
-    switch(outputScript.type) {
-        case "pkh":
-        case "sh":
-        case "wpkh":
-        case "wsh":
-            return Buffer.from(OutScript.encode({
-                type: outputScript.type,
-                hash: outputScript.hash
-            }));
-        case "tr":
-            try {
-                return Buffer.from(OutScript.encode({
-                    type: "tr",
-                    pubkey: outputScript.pubkey
-                }));
-            } catch (e: any) {
-                let msg = "";
-                if(e.name!=null) msg += ": "+e.name;
-                if(e.message!=null) msg += ": "+e.message;
-                if(typeof(e)==="string") msg += ": "+e;
-                msg += ", isBytes: "+isBytes(outputScript.pubkey);
-                try {
-                    validatePubkey(outputScript.pubkey, PubT.schnorr)
-                    msg += ", validatePubkey: success";
-                } catch (e: any) {
-                    msg += ", validatePubkeyError: ";
-                    if(e.name!=null) msg += ": "+e.name;
-                    if(e.message!=null) msg += ": "+e.message;
-                    if(typeof(e)==="string") msg += ": "+e;
-                }
-                throw new Error(msg);
-            }
-    }
-    throw new Error(`Unrecognized output script type: ${outputScript.type}`);
-}
-
-export function toCoinselectAddressType(outputScript: Uint8Array): CoinselectAddressTypes {
-    const data = OutScript.decode(outputScript);
-    switch(data.type) {
-        case "pkh":
-            return "p2pkh";
-        case "sh":
-            return "p2sh-p2wpkh";
-        case "wpkh":
-            return "p2wpkh"
-        case "wsh":
-            return "p2wsh"
-        case "tr":
-            return "p2tr"
-    }
-    throw new Error("Unrecognized address type!");
-}
-
-
-function getDummySpec(type: CoinselectAddressTypes) {
-    switch(type) {
-        case "p2pkh":
-            return {
-                type: "pkh",
-                hash: randomBytes(20)
-            } as const;
-        case "p2sh-p2wpkh":
-            return {
-                type: "sh",
-                hash: randomBytes(20)
-            } as const;
-        case "p2wpkh":
-            return {
-                type: "wpkh",
-                hash: randomBytes(20)
-            } as const;
-        case "p2wsh":
-            return {
-                type: "wsh",
-                hash: randomBytes(32)
-            } as const;
-        case "p2tr":
-            return {
-                type: "tr",
-                pubkey: Buffer.from("0101010101010101010101010101010101010101010101010101010101010101", "hex")
-            } as const;
-    }
-    throw new Error("Unrecognized address type!");
-}
-
-export function getDummyOutputScript(type: CoinselectAddressTypes): Uint8Array {
-    return OutScript.encode(getDummySpec(type));
-}
-
-export function getDummyAddress(network: BTC_NETWORK, type: CoinselectAddressTypes): string {
-    return Address(network).encode(getDummySpec(type));
-}
-
-/**
- * General parsers for PSBTs, can parse hex or base64 encoded PSBTs
- * @param _psbt
- */
-export function parsePsbtTransaction(_psbt: Transaction | string): Transaction {
-    if (typeof (_psbt) === "string") {
-        let rawPsbt: Buffer;
-        if (/^(?:[0-9a-fA-F]{2})+$/.test(_psbt)) {
-            //Hex
-            rawPsbt = Buffer.from(_psbt, "hex");
-        } else if (/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(_psbt)) {
-            //Base64
-            rawPsbt = Buffer.from(_psbt, "base64");
-        } else {
-            throw new Error("Provided psbt string not base64 nor hex encoded!");
-        }
-        return Transaction.fromPSBT(rawPsbt, {
-            allowUnknownOutputs: true,
-            allowUnknownInputs: true,
-            allowLegacyWitnessUtxo: true,
-        });
-    } else {
-        return _psbt;
-    }
-}
-
+import {BTC_NETWORK, isBytes, PubT, validatePubkey} from "@scure/btc-signer/utils";
+import {Buffer} from "buffer";
+import {Address, OutScript, Transaction} from "@scure/btc-signer";
+import {CoinselectAddressTypes} from "../bitcoin/coinselect2";
+import { randomBytes } from "./Utils";
+
+
+export function fromOutputScript(network: BTC_NETWORK, outputScriptHex: string): string {
+    return Address(network).encode(OutScript.decode(Buffer.from(outputScriptHex, "hex")));
+}
+
+export function toOutputScript(network: BTC_NETWORK, address: string): Buffer {
+    const outputScript = Address(network).decode(address);
+    switch(outputScript.type) {
+        case "pkh":
+        case "sh":
+        case "wpkh":
+        case "wsh":
+            return Buffer.from(OutScript.encode({
+                type: outputScript.type,
+                hash: outputScript.hash
+            }));
+        case "tr":
+            try {
+                return Buffer.from(OutScript.encode({
+                    type: "tr",
+                    pubkey: outputScript.pubkey
+                }));
+            } catch (e: any) {
+                let msg = "";
+                if(e.name!=null) msg += ": "+e.name;
+                if(e.message!=null) msg += ": "+e.message;
+                if(typeof(e)==="string") msg += ": "+e;
+                msg += ", isBytes: "+isBytes(outputScript.pubkey);
+                try {
+                    validatePubkey(outputScript.pubkey, PubT.schnorr)
+                    msg += ", validatePubkey: success";
+                } catch (e: any) {
+                    msg += ", validatePubkeyError: ";
+                    if(e.name!=null) msg += ": "+e.name;
+                    if(e.message!=null) msg += ": "+e.message;
+                    if(typeof(e)==="string") msg += ": "+e;
+                }
+                throw new Error(msg);
+            }
+    }
+    throw new Error(`Unrecognized output script type: ${outputScript.type}`);
+}
+
+export function toCoinselectAddressType(outputScript: Uint8Array): CoinselectAddressTypes {
+    const data = OutScript.decode(outputScript);
+    switch(data.type) {
+        case "pkh":
+            return "p2pkh";
+        case "sh":
+            return "p2sh-p2wpkh";
+        case "wpkh":
+            return "p2wpkh"
+        case "wsh":
+            return "p2wsh"
+        case "tr":
+            return "p2tr"
+    }
+    throw new Error("Unrecognized address type!");
+}
+
+
+function getDummySpec(type: CoinselectAddressTypes) {
+    switch(type) {
+        case "p2pkh":
+            return {
+                type: "pkh",
+                hash: randomBytes(20)
+            } as const;
+        case "p2sh-p2wpkh":
+            return {
+                type: "sh",
+                hash: randomBytes(20)
+            } as const;
+        case "p2wpkh":
+            return {
+                type: "wpkh",
+                hash: randomBytes(20)
+            } as const;
+        case "p2wsh":
+            return {
+                type: "wsh",
+                hash: randomBytes(32)
+            } as const;
+        case "p2tr":
+            return {
+                type: "tr",
+                pubkey: Buffer.from("0101010101010101010101010101010101010101010101010101010101010101", "hex")
+            } as const;
+    }
+    throw new Error("Unrecognized address type!");
+}
+
+export function getDummyOutputScript(type: CoinselectAddressTypes): Uint8Array {
+    return OutScript.encode(getDummySpec(type));
+}
+
+export function getDummyAddress(network: BTC_NETWORK, type: CoinselectAddressTypes): string {
+    return Address(network).encode(getDummySpec(type));
+}
+
+/**
+ * General parsers for PSBTs, can parse hex or base64 encoded PSBTs
+ * @param _psbt
+ */
+export function parsePsbtTransaction(_psbt: Transaction | string): Transaction {
+    if (typeof (_psbt) === "string") {
+        let rawPsbt: Buffer;
+        if (/^(?:[0-9a-fA-F]{2})+$/.test(_psbt)) {
+            //Hex
+            rawPsbt = Buffer.from(_psbt, "hex");
+        } else if (/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(_psbt)) {
+            //Base64
+            rawPsbt = Buffer.from(_psbt, "base64");
+        } else {
+            throw new Error("Provided psbt string not base64 nor hex encoded!");
+        }
+        return Transaction.fromPSBT(rawPsbt, {
+            allowUnknownOutputs: true,
+            allowUnknownInputs: true,
+            allowLegacyWitnessUtxo: true,
+        });
+    } else {
+        return _psbt;
+    }
+}
+