@atomiqlabs/sdk 8.9.1 → 8.9.2

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,164 +1,164 @@
-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;
-    }
-}
-
-export function getVoutIndex(psbt: Transaction, network: BTC_NETWORK, address: string, amount: bigint): number | undefined {
-    const script = toOutputScript(network, address);
-    for(let i=0;i<psbt.outputsLength;i++) {
-        const output = psbt.getOutput(i);
-        if(
-            output.amount===amount &&
-            output.script!=null &&
-            script.equals(Buffer.from(output.script))
-        ) {
-            return i;
-        }
-    }
-}
-
-export function getSenderAddress(psbt: Transaction, network: BTC_NETWORK, inputIndex: number = 0): string | undefined {
-    if(psbt.inputsLength<=inputIndex) return undefined;
-
-    const input = psbt.getInput(inputIndex);
-    let script: Uint8Array | undefined;
-    if(input.witnessUtxo?.script!=null) {
-        script = input.witnessUtxo.script as Uint8Array;
-    } else if(input.nonWitnessUtxo!=null && input.index!=null) {
-        script = input.nonWitnessUtxo.outputs[input.index]?.script;
-    }
-    if(script==null) return undefined;
-
-    try {
-        return Address(network).encode(OutScript.decode(script));
-    } catch (e) {
-        return Buffer.from(script).toString("hex");
-    }
-}
+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;
+    }
+}
+
+export function getVoutIndex(psbt: Transaction, network: BTC_NETWORK, address: string, amount: bigint): number | undefined {
+    const script = toOutputScript(network, address);
+    for(let i=0;i<psbt.outputsLength;i++) {
+        const output = psbt.getOutput(i);
+        if(
+            output.amount===amount &&
+            output.script!=null &&
+            script.equals(Buffer.from(output.script))
+        ) {
+            return i;
+        }
+    }
+}
+
+export function getSenderAddress(psbt: Transaction, network: BTC_NETWORK, inputIndex: number = 0): string | undefined {
+    if(psbt.inputsLength<=inputIndex) return undefined;
+
+    const input = psbt.getInput(inputIndex);
+    let script: Uint8Array | undefined;
+    if(input.witnessUtxo?.script!=null) {
+        script = input.witnessUtxo.script as Uint8Array;
+    } else if(input.nonWitnessUtxo!=null && input.index!=null) {
+        script = input.nonWitnessUtxo.outputs[input.index]?.script;
+    }
+    if(script==null) return undefined;
+
+    try {
+        return Address(network).encode(OutScript.decode(script));
+    } catch (e) {
+        return Buffer.from(script).toString("hex");
+    }
+}

package/src/utils/BitcoinWalletUtils.ts

@@ -1,16 +1,16 @@
-import {IBitcoinWallet, isIBitcoinWallet} from "../bitcoin/wallet/IBitcoinWallet";
-import {BTC_NETWORK} from "@scure/btc-signer/utils";
-import {SingleAddressBitcoinWallet} from "../bitcoin/wallet/SingleAddressBitcoinWallet";
-import {BitcoinNetwork, BitcoinRpcWithAddressIndex} from "@atomiqlabs/base";
-
-export function toBitcoinWallet(
-    _bitcoinWallet: IBitcoinWallet | { address: string, publicKey: string },
-    btcRpc: BitcoinRpcWithAddressIndex<any>,
-    bitcoinNetwork: BTC_NETWORK | BitcoinNetwork
-): IBitcoinWallet {
-    if (isIBitcoinWallet(_bitcoinWallet)) {
-        return _bitcoinWallet;
-    } else {
-        return new SingleAddressBitcoinWallet(btcRpc, bitcoinNetwork, _bitcoinWallet);
-    }
+import {IBitcoinWallet, isIBitcoinWallet} from "../bitcoin/wallet/IBitcoinWallet";
+import {BTC_NETWORK} from "@scure/btc-signer/utils";
+import {SingleAddressBitcoinWallet} from "../bitcoin/wallet/SingleAddressBitcoinWallet";
+import {BitcoinNetwork, BitcoinRpcWithAddressIndex} from "@atomiqlabs/base";
+
+export function toBitcoinWallet(
+    _bitcoinWallet: IBitcoinWallet | { address: string, publicKey: string },
+    btcRpc: BitcoinRpcWithAddressIndex<any>,
+    bitcoinNetwork: BTC_NETWORK | BitcoinNetwork
+): IBitcoinWallet {
+    if (isIBitcoinWallet(_bitcoinWallet)) {
+        return _bitcoinWallet;
+    } else {
+        return new SingleAddressBitcoinWallet(btcRpc, bitcoinNetwork, _bitcoinWallet);
+    }
 }

package/src/utils/Logger.ts

@@ -1,15 +1,15 @@
-export type LoggerType = {
-    debug: (msg: string, ...args: any[]) => void,
-    info: (msg: string, ...args: any[]) => void,
-    warn: (msg: string, ...args: any[]) => void,
-    error: (msg: string, ...args: any[]) => void
-};
-
-export function getLogger(prefix: string): LoggerType {
-    return {
-        debug: (msg, ...args) => (global as any).atomiqLogLevel >= 3 && console.debug(prefix + msg, ...args),
-        info: (msg, ...args) => (global as any).atomiqLogLevel >= 2 && console.info(prefix + msg, ...args),
-        warn: (msg, ...args) => ((global as any).atomiqLogLevel == null || (global as any).atomiqLogLevel >= 1) && console.warn(prefix + msg, ...args),
-        error: (msg, ...args) => ((global as any).atomiqLogLevel == null || (global as any).atomiqLogLevel >= 0) && console.error(prefix + msg, ...args)
-    };
+export type LoggerType = {
+    debug: (msg: string, ...args: any[]) => void,
+    info: (msg: string, ...args: any[]) => void,
+    warn: (msg: string, ...args: any[]) => void,
+    error: (msg: string, ...args: any[]) => void
+};
+
+export function getLogger(prefix: string): LoggerType {
+    return {
+        debug: (msg, ...args) => (global as any).atomiqLogLevel >= 3 && console.debug(prefix + msg, ...args),
+        info: (msg, ...args) => (global as any).atomiqLogLevel >= 2 && console.info(prefix + msg, ...args),
+        warn: (msg, ...args) => ((global as any).atomiqLogLevel == null || (global as any).atomiqLogLevel >= 1) && console.warn(prefix + msg, ...args),
+        error: (msg, ...args) => ((global as any).atomiqLogLevel == null || (global as any).atomiqLogLevel >= 0) && console.error(prefix + msg, ...args)
+    };
 }