@atomiqlabs/sdk 8.7.7 → 8.8.4

package/dist/utils/BitcoinUtils.d.ts

@@ -1,14 +1,16 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { BTC_NETWORK } from "@scure/btc-signer/utils";
-import { Buffer } from "buffer";
-import { Transaction } from "@scure/btc-signer";
-import { CoinselectAddressTypes } from "../bitcoin/coinselect2";
-export declare function fromOutputScript(network: BTC_NETWORK, outputScriptHex: string): string;
-export declare function toOutputScript(network: BTC_NETWORK, address: string): Buffer;
-export declare function toCoinselectAddressType(outputScript: Uint8Array): CoinselectAddressTypes;
-/**
- * General parsers for PSBTs, can parse hex or base64 encoded PSBTs
- * @param _psbt
- */
-export declare function parsePsbtTransaction(_psbt: Transaction | string): Transaction;
+/// <reference types="node" />
+/// <reference types="node" />
+import { BTC_NETWORK } from "@scure/btc-signer/utils";
+import { Buffer } from "buffer";
+import { Transaction } from "@scure/btc-signer";
+import { CoinselectAddressTypes } from "../bitcoin/coinselect2";
+export declare function fromOutputScript(network: BTC_NETWORK, outputScriptHex: string): string;
+export declare function toOutputScript(network: BTC_NETWORK, address: string): Buffer;
+export declare function toCoinselectAddressType(outputScript: Uint8Array): CoinselectAddressTypes;
+export declare function getDummyOutputScript(type: CoinselectAddressTypes): Uint8Array;
+export declare function getDummyAddress(network: BTC_NETWORK, type: CoinselectAddressTypes): string;
+/**
+ * General parsers for PSBTs, can parse hex or base64 encoded PSBTs
+ * @param _psbt
+ */
+export declare function parsePsbtTransaction(_psbt: Transaction | string): Transaction;

package/dist/utils/BitcoinUtils.js

@@ -1,102 +1,141 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePsbtTransaction = exports.toCoinselectAddressType = exports.toOutputScript = exports.fromOutputScript = void 0;
-const utils_1 = require("@scure/btc-signer/utils");
-const buffer_1 = require("buffer");
-const btc_signer_1 = require("@scure/btc-signer");
-function fromOutputScript(network, outputScriptHex) {
-    return (0, btc_signer_1.Address)(network).encode(btc_signer_1.OutScript.decode(buffer_1.Buffer.from(outputScriptHex, "hex")));
-}
-exports.fromOutputScript = fromOutputScript;
-function toOutputScript(network, address) {
-    const outputScript = (0, btc_signer_1.Address)(network).decode(address);
-    switch (outputScript.type) {
-        case "pkh":
-        case "sh":
-        case "wpkh":
-        case "wsh":
-            return buffer_1.Buffer.from(btc_signer_1.OutScript.encode({
-                type: outputScript.type,
-                hash: outputScript.hash
-            }));
-        case "tr":
-            try {
-                return buffer_1.Buffer.from(btc_signer_1.OutScript.encode({
-                    type: "tr",
-                    pubkey: outputScript.pubkey
-                }));
-            }
-            catch (e) {
-                let msg = "";
-                if (e.name != null)
-                    msg += ": " + e.name;
-                if (e.message != null)
-                    msg += ": " + e.message;
-                if (typeof (e) === "string")
-                    msg += ": " + e;
-                msg += ", isBytes: " + (0, utils_1.isBytes)(outputScript.pubkey);
-                try {
-                    (0, utils_1.validatePubkey)(outputScript.pubkey, utils_1.PubT.schnorr);
-                    msg += ", validatePubkey: success";
-                }
-                catch (e) {
-                    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}`);
-}
-exports.toOutputScript = toOutputScript;
-function toCoinselectAddressType(outputScript) {
-    const data = btc_signer_1.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!");
-}
-exports.toCoinselectAddressType = toCoinselectAddressType;
-/**
- * General parsers for PSBTs, can parse hex or base64 encoded PSBTs
- * @param _psbt
- */
-function parsePsbtTransaction(_psbt) {
-    if (typeof (_psbt) === "string") {
-        let rawPsbt;
-        if (/^(?:[0-9a-fA-F]{2})+$/.test(_psbt)) {
-            //Hex
-            rawPsbt = buffer_1.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_1.Buffer.from(_psbt, "base64");
-        }
-        else {
-            throw new Error("Provided psbt string not base64 nor hex encoded!");
-        }
-        return btc_signer_1.Transaction.fromPSBT(rawPsbt, {
-            allowUnknownOutputs: true,
-            allowUnknownInputs: true,
-            allowLegacyWitnessUtxo: true,
-        });
-    }
-    else {
-        return _psbt;
-    }
-}
-exports.parsePsbtTransaction = parsePsbtTransaction;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePsbtTransaction = exports.getDummyAddress = exports.getDummyOutputScript = exports.toCoinselectAddressType = exports.toOutputScript = exports.fromOutputScript = void 0;
+const utils_1 = require("@scure/btc-signer/utils");
+const buffer_1 = require("buffer");
+const btc_signer_1 = require("@scure/btc-signer");
+const Utils_1 = require("./Utils");
+function fromOutputScript(network, outputScriptHex) {
+    return (0, btc_signer_1.Address)(network).encode(btc_signer_1.OutScript.decode(buffer_1.Buffer.from(outputScriptHex, "hex")));
+}
+exports.fromOutputScript = fromOutputScript;
+function toOutputScript(network, address) {
+    const outputScript = (0, btc_signer_1.Address)(network).decode(address);
+    switch (outputScript.type) {
+        case "pkh":
+        case "sh":
+        case "wpkh":
+        case "wsh":
+            return buffer_1.Buffer.from(btc_signer_1.OutScript.encode({
+                type: outputScript.type,
+                hash: outputScript.hash
+            }));
+        case "tr":
+            try {
+                return buffer_1.Buffer.from(btc_signer_1.OutScript.encode({
+                    type: "tr",
+                    pubkey: outputScript.pubkey
+                }));
+            }
+            catch (e) {
+                let msg = "";
+                if (e.name != null)
+                    msg += ": " + e.name;
+                if (e.message != null)
+                    msg += ": " + e.message;
+                if (typeof (e) === "string")
+                    msg += ": " + e;
+                msg += ", isBytes: " + (0, utils_1.isBytes)(outputScript.pubkey);
+                try {
+                    (0, utils_1.validatePubkey)(outputScript.pubkey, utils_1.PubT.schnorr);
+                    msg += ", validatePubkey: success";
+                }
+                catch (e) {
+                    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}`);
+}
+exports.toOutputScript = toOutputScript;
+function toCoinselectAddressType(outputScript) {
+    const data = btc_signer_1.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!");
+}
+exports.toCoinselectAddressType = toCoinselectAddressType;
+function getDummySpec(type) {
+    switch (type) {
+        case "p2pkh":
+            return {
+                type: "pkh",
+                hash: (0, Utils_1.randomBytes)(20)
+            };
+        case "p2sh-p2wpkh":
+            return {
+                type: "sh",
+                hash: (0, Utils_1.randomBytes)(20)
+            };
+        case "p2wpkh":
+            return {
+                type: "wpkh",
+                hash: (0, Utils_1.randomBytes)(20)
+            };
+        case "p2wsh":
+            return {
+                type: "wsh",
+                hash: (0, Utils_1.randomBytes)(32)
+            };
+        case "p2tr":
+            return {
+                type: "tr",
+                pubkey: buffer_1.Buffer.from("0101010101010101010101010101010101010101010101010101010101010101", "hex")
+            };
+    }
+    throw new Error("Unrecognized address type!");
+}
+function getDummyOutputScript(type) {
+    return btc_signer_1.OutScript.encode(getDummySpec(type));
+}
+exports.getDummyOutputScript = getDummyOutputScript;
+function getDummyAddress(network, type) {
+    return (0, btc_signer_1.Address)(network).encode(getDummySpec(type));
+}
+exports.getDummyAddress = getDummyAddress;
+/**
+ * General parsers for PSBTs, can parse hex or base64 encoded PSBTs
+ * @param _psbt
+ */
+function parsePsbtTransaction(_psbt) {
+    if (typeof (_psbt) === "string") {
+        let rawPsbt;
+        if (/^(?:[0-9a-fA-F]{2})+$/.test(_psbt)) {
+            //Hex
+            rawPsbt = buffer_1.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_1.Buffer.from(_psbt, "base64");
+        }
+        else {
+            throw new Error("Provided psbt string not base64 nor hex encoded!");
+        }
+        return btc_signer_1.Transaction.fromPSBT(rawPsbt, {
+            allowUnknownOutputs: true,
+            allowUnknownInputs: true,
+            allowLegacyWitnessUtxo: true,
+        });
+    }
+    else {
+        return _psbt;
+    }
+}
+exports.parsePsbtTransaction = parsePsbtTransaction;

package/dist/utils/BitcoinWalletUtils.d.ts

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

package/dist/utils/BitcoinWalletUtils.js

@@ -1,14 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBitcoinWallet = void 0;
-const IBitcoinWallet_1 = require("../bitcoin/wallet/IBitcoinWallet");
-const SingleAddressBitcoinWallet_1 = require("../bitcoin/wallet/SingleAddressBitcoinWallet");
-function toBitcoinWallet(_bitcoinWallet, btcRpc, bitcoinNetwork) {
-    if ((0, IBitcoinWallet_1.isIBitcoinWallet)(_bitcoinWallet)) {
-        return _bitcoinWallet;
-    }
-    else {
-        return new SingleAddressBitcoinWallet_1.SingleAddressBitcoinWallet(btcRpc, bitcoinNetwork, _bitcoinWallet);
-    }
-}
-exports.toBitcoinWallet = toBitcoinWallet;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBitcoinWallet = void 0;
+const IBitcoinWallet_1 = require("../bitcoin/wallet/IBitcoinWallet");
+const SingleAddressBitcoinWallet_1 = require("../bitcoin/wallet/SingleAddressBitcoinWallet");
+function toBitcoinWallet(_bitcoinWallet, btcRpc, bitcoinNetwork) {
+    if ((0, IBitcoinWallet_1.isIBitcoinWallet)(_bitcoinWallet)) {
+        return _bitcoinWallet;
+    }
+    else {
+        return new SingleAddressBitcoinWallet_1.SingleAddressBitcoinWallet(btcRpc, bitcoinNetwork, _bitcoinWallet);
+    }
+}
+exports.toBitcoinWallet = toBitcoinWallet;

package/dist/utils/Logger.d.ts

@@ -1,7 +1,7 @@
-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 declare function getLogger(prefix: string): LoggerType;
+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 declare function getLogger(prefix: string): LoggerType;

package/dist/utils/Logger.js

@@ -1,12 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLogger = void 0;
-function getLogger(prefix) {
-    return {
-        debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug(prefix + msg, ...args),
-        info: (msg, ...args) => global.atomiqLogLevel >= 2 && console.info(prefix + msg, ...args),
-        warn: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 1) && console.warn(prefix + msg, ...args),
-        error: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 0) && console.error(prefix + msg, ...args)
-    };
-}
-exports.getLogger = getLogger;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = void 0;
+function getLogger(prefix) {
+    return {
+        debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug(prefix + msg, ...args),
+        info: (msg, ...args) => global.atomiqLogLevel >= 2 && console.info(prefix + msg, ...args),
+        warn: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 1) && console.warn(prefix + msg, ...args),
+        error: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 0) && console.error(prefix + msg, ...args)
+    };
+}
+exports.getLogger = getLogger;

package/dist/utils/RetryUtils.d.ts

@@ -1,22 +1,22 @@
-type Constructor<T = any> = new (...args: any[]) => T;
-/**
- * Runs the passed function multiple times if it fails
- *
- * @param func A callback for executing the action
- * @param func.retryCount Count of the current retry, starting from 0 for original request and increasing
- * @param retryPolicy Retry policy
- * @param retryPolicy.maxRetries How many retries to attempt in total
- * @param retryPolicy.delay How long should the delay be
- * @param retryPolicy.exponential Whether to use exponentially increasing delays
- * @param errorAllowed A callback for determining whether a given error is allowed, and we should therefore not retry
- * @param abortSignal
- * @param failureLogLevel
- * @returns Result of the action executing callback
- * @category Utilities
- */
-export declare function tryWithRetries<T>(func: (retryCount: number) => Promise<T>, retryPolicy?: {
-    maxRetries?: number;
-    delay?: number;
-    exponential?: boolean;
-}, errorAllowed?: ((e: any) => boolean) | Constructor<Error> | Constructor<Error>[], abortSignal?: AbortSignal, failureLogLevel?: "debug" | "info" | "warn" | "error"): Promise<T>;
-export {};
+type Constructor<T = any> = new (...args: any[]) => T;
+/**
+ * Runs the passed function multiple times if it fails
+ *
+ * @param func A callback for executing the action
+ * @param func.retryCount Count of the current retry, starting from 0 for original request and increasing
+ * @param retryPolicy Retry policy
+ * @param retryPolicy.maxRetries How many retries to attempt in total
+ * @param retryPolicy.delay How long should the delay be
+ * @param retryPolicy.exponential Whether to use exponentially increasing delays
+ * @param errorAllowed A callback for determining whether a given error is allowed, and we should therefore not retry
+ * @param abortSignal
+ * @param failureLogLevel
+ * @returns Result of the action executing callback
+ * @category Utilities
+ */
+export declare function tryWithRetries<T>(func: (retryCount: number) => Promise<T>, retryPolicy?: {
+    maxRetries?: number;
+    delay?: number;
+    exponential?: boolean;
+}, errorAllowed?: ((e: any) => boolean) | Constructor<Error> | Constructor<Error>[], abortSignal?: AbortSignal, failureLogLevel?: "debug" | "info" | "warn" | "error"): Promise<T>;
+export {};

package/dist/utils/RetryUtils.js

@@ -1,67 +1,67 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryWithRetries = void 0;
-const TimeoutUtils_1 = require("./TimeoutUtils");
-const Logger_1 = require("./Logger");
-const logger = (0, Logger_1.getLogger)("RetryUtils: ");
-function isConstructor(fn) {
-    return (typeof fn === 'function' &&
-        fn.prototype != null &&
-        fn.prototype.constructor === fn);
-}
-function isConstructorArray(fnArr) {
-    return Array.isArray(fnArr) && fnArr.every(isConstructor);
-}
-/**
- * Checks whether the passed error is allowed to pass through
- *
- * @param e Error in question
- * @param errorAllowed Allowed errors as defined as a callback function, specific error type, or an array of error types
- */
-function checkError(e, errorAllowed) {
-    if (isConstructorArray(errorAllowed))
-        return errorAllowed.find(error => e instanceof error) != null;
-    if (isConstructor(errorAllowed))
-        return e instanceof errorAllowed;
-    return errorAllowed(e);
-}
-/**
- * Runs the passed function multiple times if it fails
- *
- * @param func A callback for executing the action
- * @param func.retryCount Count of the current retry, starting from 0 for original request and increasing
- * @param retryPolicy Retry policy
- * @param retryPolicy.maxRetries How many retries to attempt in total
- * @param retryPolicy.delay How long should the delay be
- * @param retryPolicy.exponential Whether to use exponentially increasing delays
- * @param errorAllowed A callback for determining whether a given error is allowed, and we should therefore not retry
- * @param abortSignal
- * @param failureLogLevel
- * @returns Result of the action executing callback
- * @category Utilities
- */
-async function tryWithRetries(func, retryPolicy, errorAllowed, abortSignal, failureLogLevel = "warn") {
-    retryPolicy = retryPolicy || {};
-    retryPolicy.maxRetries = retryPolicy.maxRetries || 5;
-    retryPolicy.delay = retryPolicy.delay || 500;
-    retryPolicy.exponential = retryPolicy.exponential == null ? true : retryPolicy.exponential;
-    let err = null;
-    for (let i = 0; i < retryPolicy.maxRetries; i++) {
-        try {
-            return await func(i);
-        }
-        catch (e) {
-            if (errorAllowed != null && checkError(e, errorAllowed))
-                throw e;
-            err = e;
-            logger[failureLogLevel]("tryWithRetries(): Error on try number: " + i, e);
-        }
-        if (abortSignal != null && abortSignal.aborted)
-            throw (abortSignal.reason || new Error("Aborted"));
-        if (i !== retryPolicy.maxRetries - 1) {
-            await (0, TimeoutUtils_1.timeoutPromise)(retryPolicy.exponential ? retryPolicy.delay * Math.pow(2, i) : retryPolicy.delay, abortSignal);
-        }
-    }
-    throw err;
-}
-exports.tryWithRetries = tryWithRetries;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryWithRetries = void 0;
+const TimeoutUtils_1 = require("./TimeoutUtils");
+const Logger_1 = require("./Logger");
+const logger = (0, Logger_1.getLogger)("RetryUtils: ");
+function isConstructor(fn) {
+    return (typeof fn === 'function' &&
+        fn.prototype != null &&
+        fn.prototype.constructor === fn);
+}
+function isConstructorArray(fnArr) {
+    return Array.isArray(fnArr) && fnArr.every(isConstructor);
+}
+/**
+ * Checks whether the passed error is allowed to pass through
+ *
+ * @param e Error in question
+ * @param errorAllowed Allowed errors as defined as a callback function, specific error type, or an array of error types
+ */
+function checkError(e, errorAllowed) {
+    if (isConstructorArray(errorAllowed))
+        return errorAllowed.find(error => e instanceof error) != null;
+    if (isConstructor(errorAllowed))
+        return e instanceof errorAllowed;
+    return errorAllowed(e);
+}
+/**
+ * Runs the passed function multiple times if it fails
+ *
+ * @param func A callback for executing the action
+ * @param func.retryCount Count of the current retry, starting from 0 for original request and increasing
+ * @param retryPolicy Retry policy
+ * @param retryPolicy.maxRetries How many retries to attempt in total
+ * @param retryPolicy.delay How long should the delay be
+ * @param retryPolicy.exponential Whether to use exponentially increasing delays
+ * @param errorAllowed A callback for determining whether a given error is allowed, and we should therefore not retry
+ * @param abortSignal
+ * @param failureLogLevel
+ * @returns Result of the action executing callback
+ * @category Utilities
+ */
+async function tryWithRetries(func, retryPolicy, errorAllowed, abortSignal, failureLogLevel = "warn") {
+    retryPolicy = retryPolicy || {};
+    retryPolicy.maxRetries = retryPolicy.maxRetries || 5;
+    retryPolicy.delay = retryPolicy.delay || 500;
+    retryPolicy.exponential = retryPolicy.exponential == null ? true : retryPolicy.exponential;
+    let err = null;
+    for (let i = 0; i < retryPolicy.maxRetries; i++) {
+        try {
+            return await func(i);
+        }
+        catch (e) {
+            if (errorAllowed != null && checkError(e, errorAllowed))
+                throw e;
+            err = e;
+            logger[failureLogLevel]("tryWithRetries(): Error on try number: " + i, e);
+        }
+        if (abortSignal != null && abortSignal.aborted)
+            throw (abortSignal.reason || new Error("Aborted"));
+        if (i !== retryPolicy.maxRetries - 1) {
+            await (0, TimeoutUtils_1.timeoutPromise)(retryPolicy.exponential ? retryPolicy.delay * Math.pow(2, i) : retryPolicy.delay, abortSignal);
+        }
+    }
+    throw err;
+}
+exports.tryWithRetries = tryWithRetries;