@dynamic-labs/bitcoin 0.0.0-exp20240808.0

package/src/utils/hasSatsConnectFeature.js

@@ -0,0 +1,6 @@
+'use client'
+import { SATSCONNECT_FEATURE } from '../const.js';
+
+const hasSatsConnectFeature = (features) => SATSCONNECT_FEATURE in features;
+
+export { hasSatsConnectFeature };

package/src/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './fetchBtcKitConnectors';
+export * from './fetchSatsConnectConnectors';
+export { hasSatsConnectFeature } from './hasSatsConnectFeature';
+export { supportsSatsConnect } from './supportsSatsConnect';
+export { getMempoolApiUrl } from './getMempoolApiUrl';

package/src/utils/psbt/bitcoinNetworkTypeToNetworks.cjs

@@ -0,0 +1,14 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var satsConnect = require('sats-connect');
+var bitcoinjsLib = require('bitcoinjs-lib');
+
+const convertNetworkTypeForPsbt = (network) => ({
+    [satsConnect.BitcoinNetworkType.Mainnet]: bitcoinjsLib.networks.bitcoin,
+    [satsConnect.BitcoinNetworkType.Testnet]: bitcoinjsLib.networks.testnet,
+}[network]);
+
+exports.convertNetworkTypeForPsbt = convertNetworkTypeForPsbt;

package/src/utils/psbt/bitcoinNetworkTypeToNetworks.d.ts

@@ -0,0 +1,3 @@
+import { BitcoinNetworkType } from 'sats-connect';
+import { networks } from 'bitcoinjs-lib';
+export declare const convertNetworkTypeForPsbt: (network: BitcoinNetworkType) => networks.Network;

package/src/utils/psbt/bitcoinNetworkTypeToNetworks.js

@@ -0,0 +1,10 @@
+'use client'
+import { BitcoinNetworkType } from 'sats-connect';
+import { networks } from 'bitcoinjs-lib';
+
+const convertNetworkTypeForPsbt = (network) => ({
+    [BitcoinNetworkType.Mainnet]: networks.bitcoin,
+    [BitcoinNetworkType.Testnet]: networks.testnet,
+}[network]);
+
+export { convertNetworkTypeForPsbt };

package/src/utils/psbt/createSignPsbtOptions.cjs

@@ -0,0 +1,36 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var validatePsbt = require('./validator/validatePsbt.cjs');
+require('bitcoinjs-lib');
+require('@dynamic-labs/wallet-connector-core');
+require('sats-connect');
+
+const createPsbtOptions = (psbt, request) => {
+    var _a;
+    const psbtSignOptions = {
+        autoFinalized: false,
+    };
+    if (request.signature) {
+        validatePsbt.validatePsbt(psbt, request.allowedSighash, request.signature);
+        const toSignInputs = [];
+        for (const signature of request.signature) {
+            if ((_a = signature.signingIndexes) === null || _a === void 0 ? void 0 : _a.length) {
+                for (const index of signature.signingIndexes) {
+                    toSignInputs.push({
+                        address: signature.address,
+                        disableAddressValidation: signature.disableAddressValidation,
+                        index,
+                        sighashTypes: request.allowedSighash,
+                    });
+                }
+            }
+        }
+        psbtSignOptions.toSignInputs = toSignInputs;
+    }
+    return psbtSignOptions;
+};
+
+exports.createPsbtOptions = createPsbtOptions;

package/src/utils/psbt/createSignPsbtOptions.d.ts

@@ -0,0 +1,3 @@
+import { Psbt } from 'bitcoinjs-lib';
+import { BitcoinSignPsbtRequest, SignPsbtOptions } from '../../types';
+export declare const createPsbtOptions: (psbt: Psbt, request: BitcoinSignPsbtRequest) => SignPsbtOptions;

package/src/utils/psbt/createSignPsbtOptions.js

@@ -0,0 +1,32 @@
+'use client'
+import { validatePsbt } from './validator/validatePsbt.js';
+import 'bitcoinjs-lib';
+import '@dynamic-labs/wallet-connector-core';
+import 'sats-connect';
+
+const createPsbtOptions = (psbt, request) => {
+    var _a;
+    const psbtSignOptions = {
+        autoFinalized: false,
+    };
+    if (request.signature) {
+        validatePsbt(psbt, request.allowedSighash, request.signature);
+        const toSignInputs = [];
+        for (const signature of request.signature) {
+            if ((_a = signature.signingIndexes) === null || _a === void 0 ? void 0 : _a.length) {
+                for (const index of signature.signingIndexes) {
+                    toSignInputs.push({
+                        address: signature.address,
+                        disableAddressValidation: signature.disableAddressValidation,
+                        index,
+                        sighashTypes: request.allowedSighash,
+                    });
+                }
+            }
+        }
+        psbtSignOptions.toSignInputs = toSignInputs;
+    }
+    return psbtSignOptions;
+};
+
+export { createPsbtOptions };

package/src/utils/psbt/extractAddressFromInput.cjs

@@ -0,0 +1,35 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var bitcoinjsLib = require('bitcoinjs-lib');
+
+/**
+ * This method extracts the address from the input data of the psbt.
+ * The address is stored as script (Buffer) in either the witnessUtxo or nonWitnessUtxo as an output
+ */
+const extractAddressFromInput = (psbt, index, input) => {
+    var _a;
+    let script;
+    if ((_a = input.witnessUtxo) === null || _a === void 0 ? void 0 : _a.script) {
+        // eslint-disable-next-line prefer-destructuring
+        script = input.witnessUtxo.script;
+    }
+    else if (input.nonWitnessUtxo) {
+        const nonWitnessTxn = bitcoinjsLib.Transaction.fromBuffer(input.nonWitnessUtxo);
+        const txOut = nonWitnessTxn.outs[psbt.txInputs[index].index];
+        // eslint-disable-next-line prefer-destructuring
+        script = txOut.script;
+    }
+    if (!script)
+        return;
+    try {
+        return bitcoinjsLib.address.fromOutputScript(script);
+    }
+    catch (e) {
+        throw new Error('address not found in output script');
+    }
+};
+
+exports.extractAddressFromInput = extractAddressFromInput;

package/src/utils/psbt/extractAddressFromInput.d.ts

@@ -0,0 +1,6 @@
+import { Psbt } from 'bitcoinjs-lib';
+/**
+ * This method extracts the address from the input data of the psbt.
+ * The address is stored as script (Buffer) in either the witnessUtxo or nonWitnessUtxo as an output
+ */
+export declare const extractAddressFromInput: (psbt: Psbt, index: number, input: Psbt['data']['inputs'][0]) => string | undefined;

package/src/utils/psbt/extractAddressFromInput.js

@@ -0,0 +1,31 @@
+'use client'
+import { Transaction, address } from 'bitcoinjs-lib';
+
+/**
+ * This method extracts the address from the input data of the psbt.
+ * The address is stored as script (Buffer) in either the witnessUtxo or nonWitnessUtxo as an output
+ */
+const extractAddressFromInput = (psbt, index, input) => {
+    var _a;
+    let script;
+    if ((_a = input.witnessUtxo) === null || _a === void 0 ? void 0 : _a.script) {
+        // eslint-disable-next-line prefer-destructuring
+        script = input.witnessUtxo.script;
+    }
+    else if (input.nonWitnessUtxo) {
+        const nonWitnessTxn = Transaction.fromBuffer(input.nonWitnessUtxo);
+        const txOut = nonWitnessTxn.outs[psbt.txInputs[index].index];
+        // eslint-disable-next-line prefer-destructuring
+        script = txOut.script;
+    }
+    if (!script)
+        return;
+    try {
+        return address.fromOutputScript(script);
+    }
+    catch (e) {
+        throw new Error('address not found in output script');
+    }
+};
+
+export { extractAddressFromInput };

package/src/utils/psbt/getSigHashType.cjs

@@ -0,0 +1,36 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var bitcoinjsLib = require('bitcoinjs-lib');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+
+/**
+ * This method will return the signature hash type for the current input.
+ * If there is a sighashType, it will return that
+ * If there is a witnessUtxo AND it is a taproot address, then it will return SIGHASH_DEFAULT
+ * Otherwise, it will return SIGHASH_ALL
+ */
+const getSigHashType = (input) => {
+    var _a;
+    if (input === null || input === void 0 ? void 0 : input.sighashType)
+        return input.sighashType;
+    let isTaprootAddress = false;
+    if ((_a = input.witnessUtxo) === null || _a === void 0 ? void 0 : _a.script) {
+        try {
+            bitcoinjsLib.payments.p2tr({
+                output: input.witnessUtxo.script,
+            });
+            isTaprootAddress = true;
+        }
+        catch (_) {
+            walletConnectorCore.logger.debug('address is not taproot');
+        }
+    }
+    return isTaprootAddress
+        ? bitcoinjsLib.Transaction.SIGHASH_DEFAULT
+        : bitcoinjsLib.Transaction.SIGHASH_ALL;
+};
+
+exports.getSigHashType = getSigHashType;

package/src/utils/psbt/getSigHashType.d.ts

@@ -0,0 +1,8 @@
+import { Psbt } from 'bitcoinjs-lib';
+/**
+ * This method will return the signature hash type for the current input.
+ * If there is a sighashType, it will return that
+ * If there is a witnessUtxo AND it is a taproot address, then it will return SIGHASH_DEFAULT
+ * Otherwise, it will return SIGHASH_ALL
+ */
+export declare const getSigHashType: (input: Psbt['data']['inputs'][0]) => number;

package/src/utils/psbt/getSigHashType.js

@@ -0,0 +1,32 @@
+'use client'
+import { payments, Transaction } from 'bitcoinjs-lib';
+import { logger } from '@dynamic-labs/wallet-connector-core';
+
+/**
+ * This method will return the signature hash type for the current input.
+ * If there is a sighashType, it will return that
+ * If there is a witnessUtxo AND it is a taproot address, then it will return SIGHASH_DEFAULT
+ * Otherwise, it will return SIGHASH_ALL
+ */
+const getSigHashType = (input) => {
+    var _a;
+    if (input === null || input === void 0 ? void 0 : input.sighashType)
+        return input.sighashType;
+    let isTaprootAddress = false;
+    if ((_a = input.witnessUtxo) === null || _a === void 0 ? void 0 : _a.script) {
+        try {
+            payments.p2tr({
+                output: input.witnessUtxo.script,
+            });
+            isTaprootAddress = true;
+        }
+        catch (_) {
+            logger.debug('address is not taproot');
+        }
+    }
+    return isTaprootAddress
+        ? Transaction.SIGHASH_DEFAULT
+        : Transaction.SIGHASH_ALL;
+};
+
+export { getSigHashType };

package/src/utils/psbt/index.d.ts

@@ -0,0 +1,5 @@
+export { validatePsbt } from './validator/validatePsbt';
+export { getSigHashType } from './getSigHashType';
+export { extractAddressFromInput } from './extractAddressFromInput';
+export { convertNetworkTypeForPsbt } from './bitcoinNetworkTypeToNetworks';
+export { sighashNumberToString } from './sighashNumberToString';

package/src/utils/psbt/sighashNumberToString.cjs

@@ -0,0 +1,27 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var bitcoinjsLib = require('bitcoinjs-lib');
+
+const sighashNumberToString = (sighashType) => {
+    switch (sighashType) {
+        case bitcoinjsLib.Transaction.SIGHASH_ALL:
+            return 'ALL';
+        case bitcoinjsLib.Transaction.SIGHASH_NONE:
+            return 'NONE';
+        case bitcoinjsLib.Transaction.SIGHASH_SINGLE:
+            return 'SINGLE';
+        case bitcoinjsLib.Transaction.SIGHASH_ALL + bitcoinjsLib.Transaction.SIGHASH_ANYONECANPAY:
+            return 'ALL|ANYONECANPAY';
+        case bitcoinjsLib.Transaction.SIGHASH_NONE + bitcoinjsLib.Transaction.SIGHASH_ANYONECANPAY:
+            return 'NONE|ANYONECANPAY';
+        case bitcoinjsLib.Transaction.SIGHASH_SINGLE + bitcoinjsLib.Transaction.SIGHASH_ANYONECANPAY:
+            return 'SINGLE|ANYONECANPAY';
+        default:
+            return;
+    }
+};
+
+exports.sighashNumberToString = sighashNumberToString;

package/src/utils/psbt/sighashNumberToString.d.ts

@@ -0,0 +1,2 @@
+import { BitcoinSigHashFlag } from '../../types';
+export declare const sighashNumberToString: (sighashType: number) => BitcoinSigHashFlag | undefined;

package/src/utils/psbt/sighashNumberToString.js

@@ -0,0 +1,23 @@
+'use client'
+import { Transaction } from 'bitcoinjs-lib';
+
+const sighashNumberToString = (sighashType) => {
+    switch (sighashType) {
+        case Transaction.SIGHASH_ALL:
+            return 'ALL';
+        case Transaction.SIGHASH_NONE:
+            return 'NONE';
+        case Transaction.SIGHASH_SINGLE:
+            return 'SINGLE';
+        case Transaction.SIGHASH_ALL + Transaction.SIGHASH_ANYONECANPAY:
+            return 'ALL|ANYONECANPAY';
+        case Transaction.SIGHASH_NONE + Transaction.SIGHASH_ANYONECANPAY:
+            return 'NONE|ANYONECANPAY';
+        case Transaction.SIGHASH_SINGLE + Transaction.SIGHASH_ANYONECANPAY:
+            return 'SINGLE|ANYONECANPAY';
+        default:
+            return;
+    }
+};
+
+export { sighashNumberToString };

package/src/utils/psbt/validator/index.d.ts

@@ -0,0 +1 @@
+export { validatePsbt } from './validatePsbt';

package/src/utils/psbt/validator/validateAddress.cjs

@@ -0,0 +1,19 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@dynamic-labs/utils');
+var extractAddressFromInput = require('../extractAddressFromInput.cjs');
+
+const validateAddress = (psbt, signingAddress, index, inputAtIndex) => {
+    // we need to extract the address from the input at the current signing index
+    // to be able to compare it to the address provided in the request for the current index
+    const extractedAddress = extractAddressFromInput.extractAddressFromInput(psbt, index, inputAtIndex);
+    if (!extractedAddress)
+        throw new utils.DynamicError(`validateAddress - input not found for the given address: ${signingAddress}`);
+    if (extractedAddress !== signingAddress)
+        throw new utils.DynamicError('validateAddress - address mismatch with index');
+};
+
+exports.validateAddress = validateAddress;

package/src/utils/psbt/validator/validateAddress.d.ts

@@ -0,0 +1,2 @@
+import { Psbt } from 'bitcoinjs-lib';
+export declare const validateAddress: (psbt: Psbt, signingAddress: string, index: number, inputAtIndex: Psbt['data']['inputs'][0]) => void;

package/src/utils/psbt/validator/validateAddress.js

@@ -0,0 +1,15 @@
+'use client'
+import { DynamicError } from '@dynamic-labs/utils';
+import { extractAddressFromInput } from '../extractAddressFromInput.js';
+
+const validateAddress = (psbt, signingAddress, index, inputAtIndex) => {
+    // we need to extract the address from the input at the current signing index
+    // to be able to compare it to the address provided in the request for the current index
+    const extractedAddress = extractAddressFromInput(psbt, index, inputAtIndex);
+    if (!extractedAddress)
+        throw new DynamicError(`validateAddress - input not found for the given address: ${signingAddress}`);
+    if (extractedAddress !== signingAddress)
+        throw new DynamicError('validateAddress - address mismatch with index');
+};
+
+export { validateAddress };

package/src/utils/psbt/validator/validatePsbt.cjs

@@ -0,0 +1,41 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var validateAddress = require('./validateAddress.cjs');
+var validateSigHash = require('./validateSigHash.cjs');
+
+/**
+ * This method will validate the psbt against the signature data provided in the request
+ * It checks 3 things:
+ * - That the signing index exists in the input
+ * - That the address provided in the request matches the address in the input,
+ *   unless the disableAddressValidation flag is set
+ * - That the sigHashType of the input is a member of the allowedSigHashTypes array
+ */
+const validatePsbt = (psbt, allowedSigHashTypes, signatureData) => {
+    if (!(signatureData === null || signatureData === void 0 ? void 0 : signatureData.length))
+        return;
+    for (const input of signatureData) {
+        const { address: signingAddress, signingIndexes, 
+        // request from ME in cases of multi-sig. Steven wanted this defaulted to true
+        disableAddressValidation = true, } = input;
+        if (!(signingIndexes === null || signingIndexes === void 0 ? void 0 : signingIndexes.length))
+            return;
+        // address is a required input
+        if (!signingAddress)
+            throw new Error('validatePsbt - address not provided');
+        for (const index of signingIndexes) {
+            const selectedInput = psbt.data.inputs[index];
+            if (!selectedInput)
+                throw new Error('validatePsbt - requested input not found');
+            if (!disableAddressValidation) {
+                validateAddress.validateAddress(psbt, signingAddress, index, selectedInput);
+            }
+            validateSigHash.validateSigHash(allowedSigHashTypes, selectedInput);
+        }
+    }
+};
+
+exports.validatePsbt = validatePsbt;

package/src/utils/psbt/validator/validatePsbt.d.ts

@@ -0,0 +1,11 @@
+import { Psbt } from 'bitcoinjs-lib';
+import { BitcoinSignPsbtRequestSignature } from '../../../types';
+/**
+ * This method will validate the psbt against the signature data provided in the request
+ * It checks 3 things:
+ * - That the signing index exists in the input
+ * - That the address provided in the request matches the address in the input,
+ *   unless the disableAddressValidation flag is set
+ * - That the sigHashType of the input is a member of the allowedSigHashTypes array
+ */
+export declare const validatePsbt: (psbt: Psbt, allowedSigHashTypes: number[], signatureData?: BitcoinSignPsbtRequestSignature[]) => void;

package/src/utils/psbt/validator/validatePsbt.js

@@ -0,0 +1,37 @@
+'use client'
+import { validateAddress } from './validateAddress.js';
+import { validateSigHash } from './validateSigHash.js';
+
+/**
+ * This method will validate the psbt against the signature data provided in the request
+ * It checks 3 things:
+ * - That the signing index exists in the input
+ * - That the address provided in the request matches the address in the input,
+ *   unless the disableAddressValidation flag is set
+ * - That the sigHashType of the input is a member of the allowedSigHashTypes array
+ */
+const validatePsbt = (psbt, allowedSigHashTypes, signatureData) => {
+    if (!(signatureData === null || signatureData === void 0 ? void 0 : signatureData.length))
+        return;
+    for (const input of signatureData) {
+        const { address: signingAddress, signingIndexes, 
+        // request from ME in cases of multi-sig. Steven wanted this defaulted to true
+        disableAddressValidation = true, } = input;
+        if (!(signingIndexes === null || signingIndexes === void 0 ? void 0 : signingIndexes.length))
+            return;
+        // address is a required input
+        if (!signingAddress)
+            throw new Error('validatePsbt - address not provided');
+        for (const index of signingIndexes) {
+            const selectedInput = psbt.data.inputs[index];
+            if (!selectedInput)
+                throw new Error('validatePsbt - requested input not found');
+            if (!disableAddressValidation) {
+                validateAddress(psbt, signingAddress, index, selectedInput);
+            }
+            validateSigHash(allowedSigHashTypes, selectedInput);
+        }
+    }
+};
+
+export { validatePsbt };

package/src/utils/psbt/validator/validateSigHash.cjs

@@ -0,0 +1,16 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var getSigHashType = require('../getSigHashType.cjs');
+
+const validateSigHash = (allowedSigHashTypes, selectedInput) => {
+    const sigHashType = getSigHashType.getSigHashType(selectedInput);
+    // if the request has allowedSigHashTypes, then we need to make sure that the sigHashType
+    // is a member of that array before continuing
+    if ((allowedSigHashTypes === null || allowedSigHashTypes === void 0 ? void 0 : allowedSigHashTypes.length) && !allowedSigHashTypes.includes(sigHashType))
+        throw new Error(`validatePsbt - sigHashType ${sigHashType} not in allowed list`);
+};
+
+exports.validateSigHash = validateSigHash;

package/src/utils/psbt/validator/validateSigHash.d.ts

@@ -0,0 +1,2 @@
+import { Psbt } from 'bitcoinjs-lib';
+export declare const validateSigHash: (allowedSigHashTypes: number[], selectedInput: Psbt['data']['inputs'][0]) => void;

package/src/utils/psbt/validator/validateSigHash.js

@@ -0,0 +1,12 @@
+'use client'
+import { getSigHashType } from '../getSigHashType.js';
+
+const validateSigHash = (allowedSigHashTypes, selectedInput) => {
+    const sigHashType = getSigHashType(selectedInput);
+    // if the request has allowedSigHashTypes, then we need to make sure that the sigHashType
+    // is a member of that array before continuing
+    if ((allowedSigHashTypes === null || allowedSigHashTypes === void 0 ? void 0 : allowedSigHashTypes.length) && !allowedSigHashTypes.includes(sigHashType))
+        throw new Error(`validatePsbt - sigHashType ${sigHashType} not in allowed list`);
+};
+
+export { validateSigHash };

package/src/utils/satoshisToBtc/index.d.ts

@@ -0,0 +1 @@
+export * from './satoshisToBtc';

package/src/utils/satoshisToBtc/satoshisToBtc.cjs

@@ -0,0 +1,8 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const satoshisToBtc = (satoshis) => satoshis / 100000000;
+
+exports.satoshisToBtc = satoshisToBtc;

package/src/utils/satoshisToBtc/satoshisToBtc.d.ts

@@ -0,0 +1 @@
+export declare const satoshisToBtc: (satoshis: number) => number;

package/src/utils/satoshisToBtc/satoshisToBtc.js

@@ -0,0 +1,4 @@
+'use client'
+const satoshisToBtc = (satoshis) => satoshis / 100000000;
+
+export { satoshisToBtc };

package/src/utils/supportsSatsConnect.cjs

@@ -0,0 +1,27 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _const = require('../const.cjs');
+require('@dynamic-labs/utils');
+require('../../_virtual/_tslib.cjs');
+require('sats-connect');
+require('bitcoinjs-lib');
+require('@dynamic-labs/wallet-connector-core');
+require('@dynamic-labs/wallet-book');
+require('@dynamic-labs/sdk-api-core');
+require('@wallet-standard/app');
+var hasSatsConnectFeature = require('./hasSatsConnectFeature.cjs');
+
+const supportsSatsConnect = (connector) => {
+    if (connector.key === _const.XVERSE_KEY) {
+        return true;
+    }
+    if (connector.wallet && hasSatsConnectFeature.hasSatsConnectFeature(connector.wallet.features)) {
+        return true;
+    }
+    return false;
+};
+
+exports.supportsSatsConnect = supportsSatsConnect;

package/src/utils/supportsSatsConnect.d.ts

@@ -0,0 +1,2 @@
+import { BitcoinWalletConnector } from '../connectors';
+export declare const supportsSatsConnect: (connector: BitcoinWalletConnector) => boolean;

package/src/utils/supportsSatsConnect.js

@@ -0,0 +1,23 @@
+'use client'
+import { XVERSE_KEY } from '../const.js';
+import '@dynamic-labs/utils';
+import '../../_virtual/_tslib.js';
+import 'sats-connect';
+import 'bitcoinjs-lib';
+import '@dynamic-labs/wallet-connector-core';
+import '@dynamic-labs/wallet-book';
+import '@dynamic-labs/sdk-api-core';
+import '@wallet-standard/app';
+import { hasSatsConnectFeature } from './hasSatsConnectFeature.js';
+
+const supportsSatsConnect = (connector) => {
+    if (connector.key === XVERSE_KEY) {
+        return true;
+    }
+    if (connector.wallet && hasSatsConnectFeature(connector.wallet.features)) {
+        return true;
+    }
+    return false;
+};
+
+export { supportsSatsConnect };

package/src/wallet/BitcoinWallet.cjs

@@ -0,0 +1,43 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+
+class BitcoinWallet extends walletConnectorCore.Wallet {
+    /**
+     * Sends a raw transaction
+     * @returns A promise that resolves to the transaction id
+     */
+    sendRawTransaction(rawTransaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.sync();
+            return this._connector.sendRawTransaction(rawTransaction);
+        });
+    }
+    /**
+     * Sends satoshis to a bitcoin address
+     * @returns A promise that resolves to the transaction id
+     */
+    sendBitcoin(transaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.sync();
+            return this._connector.sendBitcoin(transaction);
+        });
+    }
+    /**
+     * Sings a PSBT
+     * @returns A promise that resolves to an object with the signed PSBT
+     * or undefined if no provider is available
+     */
+    signPsbt(request) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.sync();
+            return this._connector.signPsbt(request);
+        });
+    }
+}
+
+exports.BitcoinWallet = BitcoinWallet;