@dynamic-labs/bitcoin 1.1.0-alpha.22 → 1.1.0-alpha.24

package/CHANGELOG.md

@@ -1,4 +1,19 @@
 
+## [1.1.0-alpha.24](https://github.com/dynamic-labs/DynamicAuth/compare/v1.1.0-alpha.23...v1.1.0-alpha.24) (2024-02-02)
+
+
+### Bug Fixes
+
+* remove isFullyConnected when unable to restore wallet ([#4575](https://github.com/dynamic-labs/DynamicAuth/issues/4575)) ([4504ff0](https://github.com/dynamic-labs/DynamicAuth/commit/4504ff03f594cd9a60055e6f52b7ea8001542bbe))
+
+## [1.1.0-alpha.23](https://github.com/dynamic-labs/DynamicAuth/compare/v1.1.0-alpha.22...v1.1.0-alpha.23) (2024-02-01)
+
+
+### Features
+
+* bitcoin signPsbt ([3c964de](https://github.com/dynamic-labs/DynamicAuth/commit/3c964dea8a55debaf184c5a94f0f5fabdda3c877))
+* embedded wallet email auth flow ([#4353](https://github.com/dynamic-labs/DynamicAuth/issues/4353)) ([4875da3](https://github.com/dynamic-labs/DynamicAuth/commit/4875da32c47c27facef1b1cdbdc214566bbfd171))
+
 ## [1.1.0-alpha.22](https://github.com/dynamic-labs/DynamicAuth/compare/v1.1.0-alpha.21...v1.1.0-alpha.22) (2024-02-01)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/bitcoin",
-  "version": "1.1.0-alpha.22",
+  "version": "1.1.0-alpha.24",
   "repository": {
     "type": "git",
     "url": "https://github.com/dynamic-labs/DynamicAuth.git",
@@ -26,13 +26,15 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@dynamic-labs/sdk-api": "0.0.356",
+    "@btckit/types": "^0.0.19",
+    "@dynamic-labs/sdk-api": "0.0.361",
     "@wallet-standard/app": "^1.0.1",
     "@wallet-standard/base": "^1.0.1",
+    "bitcoinjs-lib": "^6.1.5",
     "sats-connect": "^1.1.2",
-    "@dynamic-labs/utils": "1.1.0-alpha.22",
-    "@dynamic-labs/wallet-book": "1.1.0-alpha.22",
-    "@dynamic-labs/wallet-connector-core": "1.1.0-alpha.22",
+    "@dynamic-labs/utils": "1.1.0-alpha.24",
+    "@dynamic-labs/wallet-book": "1.1.0-alpha.24",
+    "@dynamic-labs/wallet-connector-core": "1.1.0-alpha.24",
     "stream": "0.0.2"
   },
   "peerDependencies": {}

package/src/BitcoinBtcKitConnector.cjs

@@ -4,8 +4,11 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../_virtual/_tslib.cjs');
 var satsConnect = require('sats-connect');
+var bitcoinjsLib = require('bitcoinjs-lib');
 var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
 var BitcoinWalletConnector = require('./BitcoinWalletConnector.cjs');
+var validatePsbt = require('./utils/psbt/validator/validatePsbt.cjs');
+var bitcoinNetworkTypeToNetworks = require('./utils/psbt/bitcoinNetworkTypeToNetworks.cjs');
 
 class BitcoinBtcKitConnector extends BitcoinWalletConnector.BitcoinWalletConnector {
     constructor(opts, btcKit) {
@@ -71,6 +74,35 @@ class BitcoinBtcKitConnector extends BitcoinWalletConnector.BitcoinWalletConnect
             return response.result.txid;
         });
     }
+    signPsbt(request) {
+        var _a, _b;
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const connectedAddress = yield this.fetchPublicAddress();
+            if (!connectedAddress || !this.btcKit) {
+                return;
+            }
+            const network = bitcoinNetworkTypeToNetworks.convertNetworkTypeForPsbt(this.currentNetwork);
+            const psbtFromBase64 = bitcoinjsLib.Psbt.fromBase64(request.unsignedPsbtBase64, {
+                network,
+            });
+            if ((_a = request.signature) === null || _a === void 0 ? void 0 : _a.length) {
+                validatePsbt.validatePsbt(psbtFromBase64, request.allowedSighash, request.signature);
+            }
+            const signPsbtRequestParams = {
+                allowedSighash: request.allowedSighash,
+                hex: psbtFromBase64.toHex(),
+                signAtIndex: (_b = request.signature) === null || _b === void 0 ? void 0 : _b.flatMap((sig) => sig.signingIndexes).filter(Number.isInteger),
+            };
+            const signedPsbtResponse = (yield this.btcKit.request('signPsbt', Object.assign({ broadcast: false, network }, signPsbtRequestParams)));
+            if (!signedPsbtResponse ||
+                !('result' in signedPsbtResponse) ||
+                !('hex' in signedPsbtResponse.result)) {
+                throw new Error('signPsbt - failed to sign PSBT');
+            }
+            const psbtHex = signedPsbtResponse.result.hex;
+            return { signedPsbt: bitcoinjsLib.Psbt.fromHex(psbtHex, { network }).toBase64() };
+        });
+    }
 }
 
 exports.BitcoinBtcKitConnector = BitcoinBtcKitConnector;

package/src/BitcoinBtcKitConnector.d.ts

@@ -1,7 +1,7 @@
 import type { BtcKitListenFn, BtcKitRequestFn } from '@btckit/types';
 import { BitcoinNetworkType } from 'sats-connect';
 import { BitcoinWalletConnector, BitcoinWalletConnectorOpts } from './BitcoinWalletConnector';
-import { BitcoinTransaction } from './types';
+import { BitcoinTransaction, BitcoinSignPsbtRequest, BitcoinSignPsbtResponse } from './types';
 export type BtcKitProvider = {
     request: BtcKitRequestFn;
     listen: BtcKitListenFn;
@@ -13,4 +13,5 @@ export declare abstract class BitcoinBtcKitConnector extends BitcoinWalletConnec
     fetchPublicAddress(): Promise<string | undefined>;
     signMessage(messageToSign: string): Promise<string | undefined>;
     sendBitcoin(transaction: BitcoinTransaction): Promise<string | undefined>;
+    signPsbt(request: BitcoinSignPsbtRequest): Promise<BitcoinSignPsbtResponse | undefined>;
 }

package/src/BitcoinBtcKitConnector.js

@@ -1,7 +1,10 @@
 import { __awaiter } from '../_virtual/_tslib.js';
 import { BitcoinNetworkType } from 'sats-connect';
+import { Psbt } from 'bitcoinjs-lib';
 import { logger } from '@dynamic-labs/wallet-connector-core';
 import { BitcoinWalletConnector } from './BitcoinWalletConnector.js';
+import { validatePsbt } from './utils/psbt/validator/validatePsbt.js';
+import { convertNetworkTypeForPsbt } from './utils/psbt/bitcoinNetworkTypeToNetworks.js';
 
 class BitcoinBtcKitConnector extends BitcoinWalletConnector {
     constructor(opts, btcKit) {
@@ -67,6 +70,35 @@ class BitcoinBtcKitConnector extends BitcoinWalletConnector {
             return response.result.txid;
         });
     }
+    signPsbt(request) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const connectedAddress = yield this.fetchPublicAddress();
+            if (!connectedAddress || !this.btcKit) {
+                return;
+            }
+            const network = convertNetworkTypeForPsbt(this.currentNetwork);
+            const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64, {
+                network,
+            });
+            if ((_a = request.signature) === null || _a === void 0 ? void 0 : _a.length) {
+                validatePsbt(psbtFromBase64, request.allowedSighash, request.signature);
+            }
+            const signPsbtRequestParams = {
+                allowedSighash: request.allowedSighash,
+                hex: psbtFromBase64.toHex(),
+                signAtIndex: (_b = request.signature) === null || _b === void 0 ? void 0 : _b.flatMap((sig) => sig.signingIndexes).filter(Number.isInteger),
+            };
+            const signedPsbtResponse = (yield this.btcKit.request('signPsbt', Object.assign({ broadcast: false, network }, signPsbtRequestParams)));
+            if (!signedPsbtResponse ||
+                !('result' in signedPsbtResponse) ||
+                !('hex' in signedPsbtResponse.result)) {
+                throw new Error('signPsbt - failed to sign PSBT');
+            }
+            const psbtHex = signedPsbtResponse.result.hex;
+            return { signedPsbt: Psbt.fromHex(psbtHex, { network }).toBase64() };
+        });
+    }
 }
 
 export { BitcoinBtcKitConnector };

package/src/BitcoinSatsConnectConnector.cjs

@@ -4,10 +4,14 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../_virtual/_tslib.cjs');
 var satsConnect = require('sats-connect');
+var bitcoinjsLib = require('bitcoinjs-lib');
 var BitcoinWalletConnector = require('./BitcoinWalletConnector.cjs');
 var _const = require('./const.cjs');
 require('@dynamic-labs/utils');
 require('@dynamic-labs/wallet-connector-core');
+var validatePsbt = require('./utils/psbt/validator/validatePsbt.cjs');
+var getSigHashType = require('./utils/psbt/getSigHashType.cjs');
+var bitcoinNetworkTypeToNetworks = require('./utils/psbt/bitcoinNetworkTypeToNetworks.cjs');
 var supportsSatsConnect = require('./utils/supportsSatsConnect.cjs');
 
 class BitcoinSatsConnectConnector extends BitcoinWalletConnector.BitcoinWalletConnector {
@@ -129,6 +133,67 @@ class BitcoinSatsConnectConnector extends BitcoinWalletConnector.BitcoinWalletCo
             });
         });
     }
+    signTransaction(params) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const { message, psbtBase64, broadcast, inputsToSign } = params;
+            return new Promise((resolve, reject) => {
+                satsConnect.signTransaction({
+                    getProvider: () => _tslib.__awaiter(this, void 0, void 0, function* () {
+                        var _a, _b;
+                        return (_b = (_a = this.wallet) === null || _a === void 0 ? void 0 : _a.features[_const.SATSCONNECT_FEATURE]) === null || _b === void 0 ? void 0 : _b.provider;
+                    }),
+                    onCancel: () => {
+                        const error = new Error();
+                        error.code = '-32000'; // error code for user cancelled
+                        reject(error);
+                    },
+                    onFinish: (response) => {
+                        resolve(response);
+                    },
+                    payload: {
+                        broadcast,
+                        inputsToSign,
+                        message: message || 'Sign Transaction',
+                        network: {
+                            type: this.currentNetwork,
+                        },
+                        psbtBase64,
+                    },
+                });
+            });
+        });
+    }
+    signPsbt(request) {
+        var _a, _b, _c, _d;
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!((_a = request.allowedSighash) === null || _a === void 0 ? void 0 : _a.length))
+                throw new Error('allowedSighash cannot be an empty array');
+            const network = bitcoinNetworkTypeToNetworks.convertNetworkTypeForPsbt(this.currentNetwork);
+            const psbtFromBase64 = bitcoinjsLib.Psbt.fromBase64(request.unsignedPsbtBase64, {
+                network,
+            });
+            if ((_b = request.signature) === null || _b === void 0 ? void 0 : _b.length) {
+                validatePsbt.validatePsbt(psbtFromBase64, request.allowedSighash, request.signature);
+            }
+            const inputsToSign = ((_d = (_c = request.signature) === null || _c === void 0 ? void 0 : _c.map((sig) => {
+                var _a;
+                return ((_a = sig.signingIndexes) !== null && _a !== void 0 ? _a : []).map((inputIndex) => ({
+                    address: sig.address,
+                    sigHash: getSigHashType.getSigHashType(psbtFromBase64.data.inputs[inputIndex]),
+                    signingIndexes: [inputIndex],
+                }));
+            })) !== null && _d !== void 0 ? _d : []).flat();
+            const signedPsbt = yield this.signTransaction({
+                broadcast: false,
+                inputsToSign,
+                psbtBase64: request.unsignedPsbtBase64,
+            });
+            if (!signedPsbt) {
+                throw new Error('Failed to sign transaction with sats-connect');
+            }
+            return { signedPsbt: signedPsbt.psbtBase64 };
+        });
+    }
 }
 
 exports.BitcoinSatsConnectConnector = BitcoinSatsConnectConnector;

package/src/BitcoinSatsConnectConnector.d.ts

@@ -1,10 +1,12 @@
-import { BitcoinNetworkType } from 'sats-connect';
+import { BitcoinNetworkType, SignTransactionResponse } from 'sats-connect';
 import { BitcoinWalletConnector, BitcoinWalletConnectorOpts } from './BitcoinWalletConnector';
-import { BitcoinTransaction } from './types';
+import { BitcoinTransaction, SatsConnectSignTransactionInput, BitcoinSignPsbtRequest, BitcoinSignPsbtResponse } from './types';
 export declare abstract class BitcoinSatsConnectConnector extends BitcoinWalletConnector {
     currentNetwork: BitcoinNetworkType;
     constructor(opts: BitcoinWalletConnectorOpts);
     fetchPublicAddress(): Promise<string | undefined>;
     signMessage(messageToSign: string): Promise<string | undefined>;
     sendBitcoin(transaction: BitcoinTransaction): Promise<string | undefined>;
+    signTransaction(params: SatsConnectSignTransactionInput): Promise<SignTransactionResponse | undefined>;
+    signPsbt(request: BitcoinSignPsbtRequest): Promise<BitcoinSignPsbtResponse | undefined>;
 }

package/src/BitcoinSatsConnectConnector.js

@@ -1,9 +1,13 @@
 import { __awaiter } from '../_virtual/_tslib.js';
-import { BitcoinNetworkType, getAddress, AddressPurpose, signMessage, sendBtcTransaction } from 'sats-connect';
+import { BitcoinNetworkType, getAddress, AddressPurpose, signMessage, sendBtcTransaction, signTransaction } from 'sats-connect';
+import { Psbt } from 'bitcoinjs-lib';
 import { BitcoinWalletConnector } from './BitcoinWalletConnector.js';
 import { SATSCONNECT_FEATURE } from './const.js';
 import '@dynamic-labs/utils';
 import '@dynamic-labs/wallet-connector-core';
+import { validatePsbt } from './utils/psbt/validator/validatePsbt.js';
+import { getSigHashType } from './utils/psbt/getSigHashType.js';
+import { convertNetworkTypeForPsbt } from './utils/psbt/bitcoinNetworkTypeToNetworks.js';
 import { supportsSatsConnect } from './utils/supportsSatsConnect.js';
 
 class BitcoinSatsConnectConnector extends BitcoinWalletConnector {
@@ -125,6 +129,67 @@ class BitcoinSatsConnectConnector extends BitcoinWalletConnector {
             });
         });
     }
+    signTransaction(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { message, psbtBase64, broadcast, inputsToSign } = params;
+            return new Promise((resolve, reject) => {
+                signTransaction({
+                    getProvider: () => __awaiter(this, void 0, void 0, function* () {
+                        var _a, _b;
+                        return (_b = (_a = this.wallet) === null || _a === void 0 ? void 0 : _a.features[SATSCONNECT_FEATURE]) === null || _b === void 0 ? void 0 : _b.provider;
+                    }),
+                    onCancel: () => {
+                        const error = new Error();
+                        error.code = '-32000'; // error code for user cancelled
+                        reject(error);
+                    },
+                    onFinish: (response) => {
+                        resolve(response);
+                    },
+                    payload: {
+                        broadcast,
+                        inputsToSign,
+                        message: message || 'Sign Transaction',
+                        network: {
+                            type: this.currentNetwork,
+                        },
+                        psbtBase64,
+                    },
+                });
+            });
+        });
+    }
+    signPsbt(request) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!((_a = request.allowedSighash) === null || _a === void 0 ? void 0 : _a.length))
+                throw new Error('allowedSighash cannot be an empty array');
+            const network = convertNetworkTypeForPsbt(this.currentNetwork);
+            const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64, {
+                network,
+            });
+            if ((_b = request.signature) === null || _b === void 0 ? void 0 : _b.length) {
+                validatePsbt(psbtFromBase64, request.allowedSighash, request.signature);
+            }
+            const inputsToSign = ((_d = (_c = request.signature) === null || _c === void 0 ? void 0 : _c.map((sig) => {
+                var _a;
+                return ((_a = sig.signingIndexes) !== null && _a !== void 0 ? _a : []).map((inputIndex) => ({
+                    address: sig.address,
+                    sigHash: getSigHashType(psbtFromBase64.data.inputs[inputIndex]),
+                    signingIndexes: [inputIndex],
+                }));
+            })) !== null && _d !== void 0 ? _d : []).flat();
+            const signedPsbt = yield this.signTransaction({
+                broadcast: false,
+                inputsToSign,
+                psbtBase64: request.unsignedPsbtBase64,
+            });
+            if (!signedPsbt) {
+                throw new Error('Failed to sign transaction with sats-connect');
+            }
+            return { signedPsbt: signedPsbt.psbtBase64 };
+        });
+    }
 }
 
 export { BitcoinSatsConnectConnector };

package/src/BitcoinWalletConnector.cjs

@@ -9,8 +9,8 @@ var utils = require('@dynamic-labs/utils');
 var sdkApi = require('@dynamic-labs/sdk-api');
 var bitcoinProviderHelper = require('./bitcoinProviderHelper.cjs');
 var BitcoinLocalStorageCache = require('./BitcoinLocalStorageCache.cjs');
-var _const = require('./const.cjs');
 var getMempoolApiUrl = require('./utils/getMempoolApiUrl.cjs');
+var _const = require('./const.cjs');
 
 class BitcoinWalletConnector extends walletConnectorCore.WalletConnectorBase {
     constructor(opts) {

package/src/BitcoinWalletConnector.d.ts

@@ -5,7 +5,7 @@ import { Chain, IBitcoinWalletConnector, WalletConnectorBase } from '@dynamic-la
 import { WalletBookSchema, WalletSchema } from '@dynamic-labs/wallet-book';
 import { WalletAdditionalAddress } from '@dynamic-labs/sdk-api';
 import { IBitcoinSessionCache } from './BitcoinLocalStorageCache';
-import { BitcoinAddress, BitcoinTransaction } from './types';
+import { BitcoinAddress, BitcoinTransaction, BitcoinSignPsbtRequest, BitcoinSignPsbtResponse } from './types';
 export type BitcoinWalletConnectorOpts = {
     walletBook: WalletBookSchema;
     walletData: WalletSchema;
@@ -30,6 +30,7 @@ export declare abstract class BitcoinWalletConnector extends WalletConnectorBase
     sendRawTransaction(rawTransaction: string): Promise<string | undefined>;
     abstract sendBitcoin(transaction: BitcoinTransaction): Promise<string | undefined>;
     getProvider<T>(): T & EventEmitter;
+    abstract signPsbt(request: BitcoinSignPsbtRequest): Promise<BitcoinSignPsbtResponse | undefined>;
     setConnectedAccountWithAddresses(mainAddress?: string, ordinalsAddress?: BitcoinAddress, paymentAddress?: BitcoinAddress, active?: boolean): Promise<void>;
     setupEventListeners(): void;
 }

package/src/BitcoinWalletConnector.js

@@ -5,8 +5,8 @@ import { DynamicError } from '@dynamic-labs/utils';
 import { WalletAddressType } from '@dynamic-labs/sdk-api';
 import { BitcoinProviderHelper } from './bitcoinProviderHelper.js';
 import { BitcoinLocalStorageCache } from './BitcoinLocalStorageCache.js';
-import { HTTP_STATUS_TOO_MANY_REQUESTS, HTTP_STATUS_NOT_FOUND } from './const.js';
 import { getMempoolApiUrl } from './utils/getMempoolApiUrl.js';
+import { HTTP_STATUS_TOO_MANY_REQUESTS, HTTP_STATUS_NOT_FOUND } from './const.js';
 
 class BitcoinWalletConnector extends WalletConnectorBase {
     constructor(opts) {

package/src/OkxConnector.cjs

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../_virtual/_tslib.cjs');
+var bitcoinjsLib = require('bitcoinjs-lib');
 var BitcoinWalletConnector = require('./BitcoinWalletConnector.cjs');
+var createSignPsbtOptions = require('./utils/psbt/createSignPsbtOptions.cjs');
 
 class OkxConnector extends BitcoinWalletConnector.BitcoinWalletConnector {
     constructor(opts) {
@@ -45,6 +47,17 @@ class OkxConnector extends BitcoinWalletConnector.BitcoinWalletConnector {
             return provider.sendBitcoin(transaction.recipientAddress, transaction.amount);
         });
     }
+    signPsbt(request) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const provider = this.getProvider();
+            if (!provider) {
+                return;
+            }
+            const psbtFromBase64 = bitcoinjsLib.Psbt.fromBase64(request.unsignedPsbtBase64);
+            const signedPsbtHex = yield provider.signPsbt(psbtFromBase64.toHex(), createSignPsbtOptions.createPsbtOptions(psbtFromBase64, request));
+            return { signedPsbt: bitcoinjsLib.Psbt.fromHex(signedPsbtHex).toBase64() };
+        });
+    }
 }
 
 exports.OkxConnector = OkxConnector;

package/src/OkxConnector.d.ts

@@ -1,5 +1,5 @@
 import { BitcoinWalletConnector, BitcoinWalletConnectorOpts } from './BitcoinWalletConnector';
-import { BitcoinTransaction } from './types';
+import { BitcoinTransaction, BitcoinSignPsbtRequest, BitcoinSignPsbtResponse } from './types';
 export declare class OkxConnector extends BitcoinWalletConnector {
     name: string;
     canFetchConnectedAccounts: boolean;
@@ -7,4 +7,5 @@ export declare class OkxConnector extends BitcoinWalletConnector {
     fetchPublicAddress(): Promise<string | undefined>;
     signMessage(messageToSign: string): Promise<string | undefined>;
     sendBitcoin(transaction: BitcoinTransaction): Promise<string | undefined>;
+    signPsbt(request: BitcoinSignPsbtRequest): Promise<BitcoinSignPsbtResponse | undefined>;
 }

package/src/OkxConnector.js

@@ -1,5 +1,7 @@
 import { __awaiter } from '../_virtual/_tslib.js';
+import { Psbt } from 'bitcoinjs-lib';
 import { BitcoinWalletConnector } from './BitcoinWalletConnector.js';
+import { createPsbtOptions } from './utils/psbt/createSignPsbtOptions.js';
 
 class OkxConnector extends BitcoinWalletConnector {
     constructor(opts) {
@@ -41,6 +43,17 @@ class OkxConnector extends BitcoinWalletConnector {
             return provider.sendBitcoin(transaction.recipientAddress, transaction.amount);
         });
     }
+    signPsbt(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.getProvider();
+            if (!provider) {
+                return;
+            }
+            const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64);
+            const signedPsbtHex = yield provider.signPsbt(psbtFromBase64.toHex(), createPsbtOptions(psbtFromBase64, request));
+            return { signedPsbt: Psbt.fromHex(signedPsbtHex).toBase64() };
+        });
+    }
 }
 
 export { OkxConnector };

package/src/UnisatConnector.cjs

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../_virtual/_tslib.cjs');
+var bitcoinjsLib = require('bitcoinjs-lib');
 var BitcoinWalletConnector = require('./BitcoinWalletConnector.cjs');
+var createSignPsbtOptions = require('./utils/psbt/createSignPsbtOptions.cjs');
 
 class UnisatConnector extends BitcoinWalletConnector.BitcoinWalletConnector {
     constructor(opts) {
@@ -46,6 +48,17 @@ class UnisatConnector extends BitcoinWalletConnector.BitcoinWalletConnector {
             return provider.sendBitcoin(transaction.recipientAddress, transaction.amount);
         });
     }
+    signPsbt(request) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const provider = this.getProvider();
+            if (!provider) {
+                return;
+            }
+            const psbtFromBase64 = bitcoinjsLib.Psbt.fromBase64(request.unsignedPsbtBase64);
+            const signedPsbtHex = yield provider.signPsbt(psbtFromBase64.toHex(), createSignPsbtOptions.createPsbtOptions(psbtFromBase64, request));
+            return { signedPsbt: bitcoinjsLib.Psbt.fromHex(signedPsbtHex).toBase64() };
+        });
+    }
 }
 
 exports.UnisatConnector = UnisatConnector;

package/src/UnisatConnector.d.ts

@@ -1,5 +1,5 @@
 import { BitcoinWalletConnector, BitcoinWalletConnectorOpts } from './BitcoinWalletConnector';
-import { BitcoinTransaction } from './types';
+import { BitcoinTransaction, BitcoinSignPsbtRequest, BitcoinSignPsbtResponse } from './types';
 export declare class UnisatConnector extends BitcoinWalletConnector {
     name: string;
     canFetchConnectedAccounts: boolean;
@@ -7,4 +7,5 @@ export declare class UnisatConnector extends BitcoinWalletConnector {
     fetchPublicAddress(): Promise<string | undefined>;
     signMessage(messageToSign: string): Promise<string | undefined>;
     sendBitcoin(transaction: BitcoinTransaction): Promise<string | undefined>;
+    signPsbt(request: BitcoinSignPsbtRequest): Promise<BitcoinSignPsbtResponse | undefined>;
 }

package/src/UnisatConnector.js

@@ -1,5 +1,7 @@
 import { __awaiter } from '../_virtual/_tslib.js';
+import { Psbt } from 'bitcoinjs-lib';
 import { BitcoinWalletConnector } from './BitcoinWalletConnector.js';
+import { createPsbtOptions } from './utils/psbt/createSignPsbtOptions.js';
 
 class UnisatConnector extends BitcoinWalletConnector {
     constructor(opts) {
@@ -42,6 +44,17 @@ class UnisatConnector extends BitcoinWalletConnector {
             return provider.sendBitcoin(transaction.recipientAddress, transaction.amount);
         });
     }
+    signPsbt(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.getProvider();
+            if (!provider) {
+                return;
+            }
+            const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64);
+            const signedPsbtHex = yield provider.signPsbt(psbtFromBase64.toHex(), createPsbtOptions(psbtFromBase64, request));
+            return { signedPsbt: Psbt.fromHex(signedPsbtHex).toBase64() };
+        });
+    }
 }
 
 export { UnisatConnector };

package/src/types.d.ts

@@ -1,4 +1,5 @@
-import { BitcoinProvider } from 'sats-connect';
+import { BitcoinProvider, InputToSign } from 'sats-connect';
+import { SignPsbtResponse as BtcKitSignPsbtResponse } from '@btckit/types';
 import type { WalletAdditionalAddress } from '@dynamic-labs/sdk-api';
 import { SATSCONNECT_FEATURE } from './const';
 export type ErrorWithCode = Error & {
@@ -21,14 +22,36 @@ export type BitcoinTransaction = {
     amount: bigint;
     recipientAddress: string;
 };
-export type SignPbstOptions = {
+export type SignPsbtOptions = {
     autoFinalized: boolean;
-    toSignInputs: SignPbstInput[];
+    toSignInputs?: {
+        index: number;
+        address: string;
+        sighashTypes?: number[];
+        disableAddressValidation?: boolean;
+    }[];
 };
-export type SignPbstInput = {
-    index: number;
+export type BitcoinSignPsbtRequest = {
+    allowedSighash: number[];
+    unsignedPsbtBase64: string;
+    signature?: BitcoinSignPsbtRequestSignature[];
+};
+export type BitcoinSignPsbtRequestSignature = {
     address: string;
-    publicKey: string;
-    sighashTypes?: number[];
-    disableTweakSigner?: boolean;
+    signingIndexes: number[] | undefined;
+    disableAddressValidation?: boolean;
+};
+export type SatsConnectSignTransactionInput = {
+    message?: string;
+    psbtBase64: string;
+    inputsToSign: InputToSign[];
+    broadcast?: boolean;
+};
+export type BtcKitSignPsbtResponseExtended = BtcKitSignPsbtResponse & {
+    result: {
+        hex: string;
+    };
+};
+export type BitcoinSignPsbtResponse = {
+    signedPsbt: string;
 };

package/src/utils/psbt/bitcoinNetworkTypeToNetworks.cjs

@@ -0,0 +1,13 @@
+'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,9 @@
+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,33 @@
+'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) {
+                toSignInputs.push({
+                    address: signature.address,
+                    disableAddressValidation: signature.disableAddressValidation,
+                    index: signature.signingIndexes[0],
+                    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,29 @@
+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) {
+                toSignInputs.push({
+                    address: signature.address,
+                    disableAddressValidation: signature.disableAddressValidation,
+                    index: signature.signingIndexes[0],
+                    sighashTypes: request.allowedSighash,
+                });
+            }
+        }
+        psbtSignOptions.toSignInputs = toSignInputs;
+    }
+    return psbtSignOptions;
+};
+
+export { createPsbtOptions };

package/src/utils/psbt/extractAddressFromInput.cjs

@@ -0,0 +1,34 @@
+'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,30 @@
+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,35 @@
+'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,31 @@
+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,4 @@
+export { validatePsbt } from './validator/validatePsbt';
+export { getSigHashType } from './getSigHashType';
+export { extractAddressFromInput } from './extractAddressFromInput';
+export { convertNetworkTypeForPsbt } from './bitcoinNetworkTypeToNetworks';

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,18 @@
+'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,14 @@
+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,40 @@
+'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,36 @@
+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,15 @@
+'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,11 @@
+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/supportsSatsConnect.cjs

@@ -6,6 +6,7 @@ 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');

package/src/utils/supportsSatsConnect.js

@@ -2,6 +2,7 @@ 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';