@atomiqlabs/sdk 8.6.6 → 8.6.8

package/dist/bitcoin/wallet/SingleAddressBitcoinWallet.js

@@ -1,176 +1,190 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SingleAddressBitcoinWallet = void 0;
-const utils_1 = require("@scure/btc-signer/utils");
-const btc_signer_1 = require("@scure/btc-signer");
-const buffer_1 = require("buffer");
-const BitcoinWallet_1 = require("./BitcoinWallet");
-const bip32_1 = require("@scure/bip32");
-const bip39_1 = require("@scure/bip39");
-const english_js_1 = require("@scure/bip39/wordlists/english.js");
-const sha2_1 = require("@noble/hashes/sha2");
-/**
- * Bitcoin wallet implementation deriving a single address from a WIF encoded private key
- *
- * @category Bitcoin
- */
-class SingleAddressBitcoinWallet extends BitcoinWallet_1.BitcoinWallet {
-    constructor(mempoolApi, _network, addressDataOrWIF, feeMultiplier = 1.25, feeOverride) {
-        const network = typeof (_network) === "object"
-            ? _network
-            : BitcoinWallet_1.BitcoinWallet.bitcoinNetworkToObject(_network);
-        super(mempoolApi, network, feeMultiplier, feeOverride);
-        if (typeof (addressDataOrWIF) === "string") {
-            try {
-                this.privKey = (0, btc_signer_1.WIF)(network).decode(addressDataOrWIF);
-            }
-            catch (e) {
-                this.privKey = (0, btc_signer_1.WIF)().decode(addressDataOrWIF);
-            }
-            this.pubkey = (0, utils_1.pubECDSA)(this.privKey);
-            const address = (0, btc_signer_1.getAddress)("wpkh", this.privKey, network);
-            if (address == null)
-                throw new Error("Failed to generate p2wpkh address from the provided private key!");
-            this.address = address;
-        }
-        else {
-            this.address = addressDataOrWIF.address;
-            this.pubkey = buffer_1.Buffer.from(addressDataOrWIF.publicKey, "hex");
-        }
-        this.addressType = (0, BitcoinWallet_1.identifyAddressType)(this.address, network);
-    }
-    /**
-     * Returns all the wallet addresses controlled by the wallet
-     *
-     * @protected
-     */
-    toBitcoinWalletAccounts() {
-        return [{
-                pubkey: buffer_1.Buffer.from(this.pubkey).toString("hex"), address: this.address, addressType: this.addressType
-            }];
-    }
-    /**
-     * @inheritDoc
-     */
-    async sendTransaction(address, amount, feeRate) {
-        if (!this.privKey)
-            throw new Error("Not supported.");
-        const { psbt, fee } = await super._getPsbt(this.toBitcoinWalletAccounts(), address, Number(amount), feeRate);
-        if (psbt == null)
-            throw new Error(`Not enough funds, required for fee: ${fee} sats!`);
-        psbt.sign(this.privKey);
-        psbt.finalize();
-        const txHex = buffer_1.Buffer.from(psbt.extract()).toString("hex");
-        return await super._sendTransaction(txHex);
-    }
-    /**
-     * @inheritDoc
-     */
-    async fundPsbt(inputPsbt, feeRate) {
-        const { psbt } = await super._fundPsbt(this.toBitcoinWalletAccounts(), inputPsbt, feeRate);
-        if (psbt == null) {
-            throw new Error("Not enough balance!");
-        }
-        return psbt;
-    }
-    /**
-     * @inheritDoc
-     */
-    async signPsbt(psbt, signInputs) {
-        if (!this.privKey)
-            throw new Error("Not supported.");
-        for (let signInput of signInputs) {
-            psbt.signIdx(this.privKey, signInput);
-        }
-        return psbt;
-    }
-    /**
-     * @inheritDoc
-     */
-    async getTransactionFee(address, amount, feeRate) {
-        const { fee } = await super._getPsbt(this.toBitcoinWalletAccounts(), address, Number(amount), feeRate);
-        return fee;
-    }
-    /**
-     * @inheritDoc
-     */
-    async getFundedPsbtFee(basePsbt, feeRate) {
-        const { fee } = await super._fundPsbt(this.toBitcoinWalletAccounts(), basePsbt, feeRate);
-        return fee;
-    }
-    /**
-     * @inheritDoc
-     */
-    getReceiveAddress() {
-        return this.address;
-    }
-    /**
-     * Returns the public key of the wallet
-     */
-    getPublicKey() {
-        return buffer_1.Buffer.from(this.pubkey).toString("hex");
-    }
-    /**
-     * @inheritDoc
-     */
-    getBalance() {
-        return this._getBalance(this.address);
-    }
-    /**
-     * @inheritDoc
-     */
-    getSpendableBalance(psbt, feeRate) {
-        return this._getSpendableBalance([{ address: this.address, addressType: this.addressType }], psbt, feeRate);
-    }
-    /**
-     * Generates a new random private key WIF that can be used to instantiate the bitcoin wallet instance
-     *
-     * @returns A WIF encoded bitcoin private key
-     */
-    static generateRandomPrivateKey(network) {
-        const networkObject = network == null || typeof (network) === "object"
-            ? network
-            : BitcoinWallet_1.BitcoinWallet.bitcoinNetworkToObject(network);
-        return (0, btc_signer_1.WIF)(networkObject).encode((0, utils_1.randomPrivateKeyBytes)());
-    }
-    /**
-     * Generates a 12-word long mnemonic from any entropy source with 128-bits or more, the entropy is first hashed
-     *  using sha256, and the first 16 bytes of the hash are used to generate the mnemonic
-     *
-     * @param entropy Entropy to use for generating the mnemonic
-     */
-    static mnemonicFromEntropy(entropy) {
-        if (entropy.length < 16)
-            throw new Error("Requires at least 128-bit entropy (16 bytes)");
-        const entropyHash = buffer_1.Buffer.from((0, sha2_1.sha256)(entropy)).subarray(0, 16);
-        return (0, bip39_1.entropyToMnemonic)(entropyHash, english_js_1.wordlist);
-    }
-    /**
-     * Generates a random 12-word long mnemonic
-     */
-    static generateRandomMnemonic() {
-        return (0, bip39_1.generateMnemonic)(english_js_1.wordlist, 128);
-    }
-    /**
-     * Generates a WIF private key from mnemonic phrase
-     *
-     * @param mnemonic Mnemonic to generate the WIF key from
-     * @param network Optional bitcoin network to generate the WIF for
-     * @param derivationPath Optional custom derivation path to use for deriving the wallet
-     */
-    static async mnemonicToPrivateKey(mnemonic, network, derivationPath) {
-        const networkObject = network == null || typeof (network) === "object"
-            ? network
-            : BitcoinWallet_1.BitcoinWallet.bitcoinNetworkToObject(network);
-        derivationPath = networkObject == null || networkObject.bech32 === utils_1.NETWORK.bech32
-            ? "m/84'/0'/0'/0/0" //Mainnet
-            : "m/84'/1'/0'/0/0"; //Testnet
-        const seed = await (0, bip39_1.mnemonicToSeed)(mnemonic);
-        const hdKey = bip32_1.HDKey.fromMasterSeed(seed);
-        const privateKey = hdKey.derive(derivationPath).privateKey;
-        if (privateKey == null)
-            throw new Error("Cannot derive private key from the mnemonic!");
-        return (0, btc_signer_1.WIF)(networkObject).encode(privateKey);
-    }
-}
-exports.SingleAddressBitcoinWallet = SingleAddressBitcoinWallet;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleAddressBitcoinWallet = void 0;
+const utils_1 = require("@scure/btc-signer/utils");
+const btc_signer_1 = require("@scure/btc-signer");
+const buffer_1 = require("buffer");
+const BitcoinWallet_1 = require("./BitcoinWallet");
+const base_1 = require("@atomiqlabs/base");
+const bip32_1 = require("@scure/bip32");
+const bip39_1 = require("@scure/bip39");
+const english_js_1 = require("@scure/bip39/wordlists/english.js");
+const sha2_1 = require("@noble/hashes/sha2");
+const logger = (0, base_1.getLogger)("SingleAddressBitcoinWallet: ");
+/**
+ * Bitcoin wallet implementation deriving a single address from a WIF encoded private key
+ *
+ * @category Bitcoin
+ */
+class SingleAddressBitcoinWallet extends BitcoinWallet_1.BitcoinWallet {
+    constructor(mempoolApi, _network, addressDataOrWIF, feeMultiplier = 1.25, feeOverride) {
+        const network = typeof (_network) === "object"
+            ? _network
+            : BitcoinWallet_1.BitcoinWallet.bitcoinNetworkToObject(_network);
+        super(mempoolApi, network, feeMultiplier, feeOverride);
+        if (typeof (addressDataOrWIF) === "string") {
+            try {
+                this.privKey = (0, btc_signer_1.WIF)(network).decode(addressDataOrWIF);
+            }
+            catch (e) {
+                this.privKey = (0, btc_signer_1.WIF)().decode(addressDataOrWIF);
+            }
+            this.pubkey = (0, utils_1.pubECDSA)(this.privKey);
+            const address = (0, btc_signer_1.getAddress)("wpkh", this.privKey, network);
+            if (address == null)
+                throw new Error("Failed to generate p2wpkh address from the provided private key!");
+            this.address = address;
+            this.addressType = (0, BitcoinWallet_1.identifyAddressType)(this.address, network);
+        }
+        else {
+            this.address = addressDataOrWIF.address;
+            this.addressType = (0, BitcoinWallet_1.identifyAddressType)(this.address, network);
+            this.pubkey = buffer_1.Buffer.from(addressDataOrWIF.publicKey, "hex");
+            // Some wallets seem to be returning a full 33-byte compressed pubkey instead of a taproot
+            //  32-byte long X-only key. Handle these cases here
+            if (this.addressType === "p2tr") {
+                if (this.pubkey.length !== 33)
+                    return;
+                const leadingByte = this.pubkey[0];
+                if (leadingByte !== 0x03 && leadingByte !== 0x02)
+                    throw new Error("Invalid public key passed for taproot bitcoin wallet, expected an X-only 32-byte public key, or a compressed 33-byte public key");
+                logger.debug(`constructor(): Converting compressed public key ${addressDataOrWIF.publicKey} to taproot X-only 32-byte public key`);
+                this.pubkey = this.pubkey.slice(1);
+            }
+        }
+    }
+    /**
+     * Returns all the wallet addresses controlled by the wallet
+     *
+     * @protected
+     */
+    toBitcoinWalletAccounts() {
+        return [{
+                pubkey: buffer_1.Buffer.from(this.pubkey).toString("hex"), address: this.address, addressType: this.addressType
+            }];
+    }
+    /**
+     * @inheritDoc
+     */
+    async sendTransaction(address, amount, feeRate) {
+        if (!this.privKey)
+            throw new Error("Not supported.");
+        const { psbt, fee } = await super._getPsbt(this.toBitcoinWalletAccounts(), address, Number(amount), feeRate);
+        if (psbt == null)
+            throw new Error(`Not enough funds, required for fee: ${fee} sats!`);
+        psbt.sign(this.privKey);
+        psbt.finalize();
+        const txHex = buffer_1.Buffer.from(psbt.extract()).toString("hex");
+        return await super._sendTransaction(txHex);
+    }
+    /**
+     * @inheritDoc
+     */
+    async fundPsbt(inputPsbt, feeRate) {
+        const { psbt } = await super._fundPsbt(this.toBitcoinWalletAccounts(), inputPsbt, feeRate);
+        if (psbt == null) {
+            throw new Error("Not enough balance!");
+        }
+        return psbt;
+    }
+    /**
+     * @inheritDoc
+     */
+    async signPsbt(psbt, signInputs) {
+        if (!this.privKey)
+            throw new Error("Not supported.");
+        for (let signInput of signInputs) {
+            psbt.signIdx(this.privKey, signInput);
+        }
+        return psbt;
+    }
+    /**
+     * @inheritDoc
+     */
+    async getTransactionFee(address, amount, feeRate) {
+        const { fee } = await super._getPsbt(this.toBitcoinWalletAccounts(), address, Number(amount), feeRate);
+        return fee;
+    }
+    /**
+     * @inheritDoc
+     */
+    async getFundedPsbtFee(basePsbt, feeRate) {
+        const { fee } = await super._fundPsbt(this.toBitcoinWalletAccounts(), basePsbt, feeRate);
+        return fee;
+    }
+    /**
+     * @inheritDoc
+     */
+    getReceiveAddress() {
+        return this.address;
+    }
+    /**
+     * Returns the public key of the wallet
+     */
+    getPublicKey() {
+        return buffer_1.Buffer.from(this.pubkey).toString("hex");
+    }
+    /**
+     * @inheritDoc
+     */
+    getBalance() {
+        return this._getBalance(this.address);
+    }
+    /**
+     * @inheritDoc
+     */
+    getSpendableBalance(psbt, feeRate) {
+        return this._getSpendableBalance([{ address: this.address, addressType: this.addressType }], psbt, feeRate);
+    }
+    /**
+     * Generates a new random private key WIF that can be used to instantiate the bitcoin wallet instance
+     *
+     * @returns A WIF encoded bitcoin private key
+     */
+    static generateRandomPrivateKey(network) {
+        const networkObject = network == null || typeof (network) === "object"
+            ? network
+            : BitcoinWallet_1.BitcoinWallet.bitcoinNetworkToObject(network);
+        return (0, btc_signer_1.WIF)(networkObject).encode((0, utils_1.randomPrivateKeyBytes)());
+    }
+    /**
+     * Generates a 12-word long mnemonic from any entropy source with 128-bits or more, the entropy is first hashed
+     *  using sha256, and the first 16 bytes of the hash are used to generate the mnemonic
+     *
+     * @param entropy Entropy to use for generating the mnemonic
+     */
+    static mnemonicFromEntropy(entropy) {
+        if (entropy.length < 16)
+            throw new Error("Requires at least 128-bit entropy (16 bytes)");
+        const entropyHash = buffer_1.Buffer.from((0, sha2_1.sha256)(entropy)).subarray(0, 16);
+        return (0, bip39_1.entropyToMnemonic)(entropyHash, english_js_1.wordlist);
+    }
+    /**
+     * Generates a random 12-word long mnemonic
+     */
+    static generateRandomMnemonic() {
+        return (0, bip39_1.generateMnemonic)(english_js_1.wordlist, 128);
+    }
+    /**
+     * Generates a WIF private key from mnemonic phrase
+     *
+     * @param mnemonic Mnemonic to generate the WIF key from
+     * @param network Optional bitcoin network to generate the WIF for
+     * @param derivationPath Optional custom derivation path to use for deriving the wallet
+     */
+    static async mnemonicToPrivateKey(mnemonic, network, derivationPath) {
+        const networkObject = network == null || typeof (network) === "object"
+            ? network
+            : BitcoinWallet_1.BitcoinWallet.bitcoinNetworkToObject(network);
+        derivationPath = networkObject == null || networkObject.bech32 === utils_1.NETWORK.bech32
+            ? "m/84'/0'/0'/0/0" //Mainnet
+            : "m/84'/1'/0'/0/0"; //Testnet
+        const seed = await (0, bip39_1.mnemonicToSeed)(mnemonic);
+        const hdKey = bip32_1.HDKey.fromMasterSeed(seed);
+        const privateKey = hdKey.derive(derivationPath).privateKey;
+        if (privateKey == null)
+            throw new Error("Cannot derive private key from the mnemonic!");
+        return (0, btc_signer_1.WIF)(networkObject).encode(privateKey);
+    }
+}
+exports.SingleAddressBitcoinWallet = SingleAddressBitcoinWallet;

package/dist/enums/FeeType.d.ts

@@ -1,15 +1,15 @@
-/**
- * Enum representing types of fees in a swap
- *
- * @category Pricing
- */
-export declare enum FeeType {
-    /**
-     * Swap fee taken by the LP
-     */
-    SWAP = 0,
-    /**
-     * Network fee to cover the transactions on the destination (output) network
-     */
-    NETWORK_OUTPUT = 1
-}
+/**
+ * Enum representing types of fees in a swap
+ *
+ * @category Pricing
+ */
+export declare enum FeeType {
+    /**
+     * Swap fee taken by the LP
+     */
+    SWAP = 0,
+    /**
+     * Network fee to cover the transactions on the destination (output) network
+     */
+    NETWORK_OUTPUT = 1
+}

package/dist/enums/FeeType.js

@@ -1,19 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FeeType = void 0;
-/**
- * Enum representing types of fees in a swap
- *
- * @category Pricing
- */
-var FeeType;
-(function (FeeType) {
-    /**
-     * Swap fee taken by the LP
-     */
-    FeeType[FeeType["SWAP"] = 0] = "SWAP";
-    /**
-     * Network fee to cover the transactions on the destination (output) network
-     */
-    FeeType[FeeType["NETWORK_OUTPUT"] = 1] = "NETWORK_OUTPUT";
-})(FeeType || (exports.FeeType = FeeType = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeeType = void 0;
+/**
+ * Enum representing types of fees in a swap
+ *
+ * @category Pricing
+ */
+var FeeType;
+(function (FeeType) {
+    /**
+     * Swap fee taken by the LP
+     */
+    FeeType[FeeType["SWAP"] = 0] = "SWAP";
+    /**
+     * Network fee to cover the transactions on the destination (output) network
+     */
+    FeeType[FeeType["NETWORK_OUTPUT"] = 1] = "NETWORK_OUTPUT";
+})(FeeType = exports.FeeType || (exports.FeeType = {}));

package/dist/enums/SwapAmountType.d.ts

@@ -1,15 +1,15 @@
-/**
- * Enum representing whether the swap amount is exact input or exact output
- *
- * @category Core
- */
-export declare enum SwapAmountType {
-    /**
-     * Swap amount specified in the input token
-     */
-    EXACT_IN = 1,
-    /**
-     * Swap amount specified in the output token
-     */
-    EXACT_OUT = 0
-}
+/**
+ * Enum representing whether the swap amount is exact input or exact output
+ *
+ * @category Core
+ */
+export declare enum SwapAmountType {
+    /**
+     * Swap amount specified in the input token
+     */
+    EXACT_IN = 1,
+    /**
+     * Swap amount specified in the output token
+     */
+    EXACT_OUT = 0
+}

package/dist/enums/SwapAmountType.js

@@ -1,19 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwapAmountType = void 0;
-/**
- * Enum representing whether the swap amount is exact input or exact output
- *
- * @category Core
- */
-var SwapAmountType;
-(function (SwapAmountType) {
-    /**
-     * Swap amount specified in the input token
-     */
-    SwapAmountType[SwapAmountType["EXACT_IN"] = 1] = "EXACT_IN";
-    /**
-     * Swap amount specified in the output token
-     */
-    SwapAmountType[SwapAmountType["EXACT_OUT"] = 0] = "EXACT_OUT";
-})(SwapAmountType || (exports.SwapAmountType = SwapAmountType = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapAmountType = void 0;
+/**
+ * Enum representing whether the swap amount is exact input or exact output
+ *
+ * @category Core
+ */
+var SwapAmountType;
+(function (SwapAmountType) {
+    /**
+     * Swap amount specified in the input token
+     */
+    SwapAmountType[SwapAmountType["EXACT_IN"] = 1] = "EXACT_IN";
+    /**
+     * Swap amount specified in the output token
+     */
+    SwapAmountType[SwapAmountType["EXACT_OUT"] = 0] = "EXACT_OUT";
+})(SwapAmountType = exports.SwapAmountType || (exports.SwapAmountType = {}));

package/dist/enums/SwapDirection.d.ts

@@ -1,15 +1,15 @@
-/**
- * Enum representing the direction of a swap (from or to Bitcoin)
- *
- * @category Core
- */
-export declare enum SwapDirection {
-    /**
-     * Swaps from bitcoin to smart chains (Solana, Starknet, EVM, etc.)
-     */
-    FROM_BTC = 0,
-    /**
-     * Swaps from smart chains (Solana, Starknet, EVM, etc.) to bitcoin
-     */
-    TO_BTC = 1
-}
+/**
+ * Enum representing the direction of a swap (from or to Bitcoin)
+ *
+ * @category Core
+ */
+export declare enum SwapDirection {
+    /**
+     * Swaps from bitcoin to smart chains (Solana, Starknet, EVM, etc.)
+     */
+    FROM_BTC = 0,
+    /**
+     * Swaps from smart chains (Solana, Starknet, EVM, etc.) to bitcoin
+     */
+    TO_BTC = 1
+}

package/dist/enums/SwapDirection.js

@@ -1,19 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwapDirection = void 0;
-/**
- * Enum representing the direction of a swap (from or to Bitcoin)
- *
- * @category Core
- */
-var SwapDirection;
-(function (SwapDirection) {
-    /**
-     * Swaps from bitcoin to smart chains (Solana, Starknet, EVM, etc.)
-     */
-    SwapDirection[SwapDirection["FROM_BTC"] = 0] = "FROM_BTC";
-    /**
-     * Swaps from smart chains (Solana, Starknet, EVM, etc.) to bitcoin
-     */
-    SwapDirection[SwapDirection["TO_BTC"] = 1] = "TO_BTC";
-})(SwapDirection || (exports.SwapDirection = SwapDirection = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapDirection = void 0;
+/**
+ * Enum representing the direction of a swap (from or to Bitcoin)
+ *
+ * @category Core
+ */
+var SwapDirection;
+(function (SwapDirection) {
+    /**
+     * Swaps from bitcoin to smart chains (Solana, Starknet, EVM, etc.)
+     */
+    SwapDirection[SwapDirection["FROM_BTC"] = 0] = "FROM_BTC";
+    /**
+     * Swaps from smart chains (Solana, Starknet, EVM, etc.) to bitcoin
+     */
+    SwapDirection[SwapDirection["TO_BTC"] = 1] = "TO_BTC";
+})(SwapDirection = exports.SwapDirection || (exports.SwapDirection = {}));

package/dist/enums/SwapSide.d.ts

@@ -1,15 +1,15 @@
-/**
- * Enum representing the side of the swap for querying available input/output tokens
- *
- * @category Core
- */
-export declare enum SwapSide {
-    /**
-     * Represents input / source side of the swap
-     */
-    INPUT = 1,
-    /**
-     * Represents output / destination side of the swap
-     */
-    OUTPUT = 0
-}
+/**
+ * Enum representing the side of the swap for querying available input/output tokens
+ *
+ * @category Core
+ */
+export declare enum SwapSide {
+    /**
+     * Represents input / source side of the swap
+     */
+    INPUT = 1,
+    /**
+     * Represents output / destination side of the swap
+     */
+    OUTPUT = 0
+}