@dynamic-labs/embedded-wallet-bitcoin 4.18.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Dynamic Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# embedded-wallet-bitcoin
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build embedded-wallet-bitcoin` to build the library.
+
+## Running unit tests
+
+Run `nx test embedded-wallet-bitcoin` to execute the unit tests via [Jest](https://jestjs.io).

package/_virtual/_tslib.cjs

@@ -0,0 +1,36 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+exports.__awaiter = __awaiter;

package/_virtual/_tslib.js

@@ -0,0 +1,32 @@
+'use client'
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+export { __awaiter };

package/package.cjs

@@ -0,0 +1,8 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var version = "4.18.7";
+
+exports.version = version;

package/package.js

@@ -0,0 +1,4 @@
+'use client'
+var version = "4.18.7";
+
+export { version };

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@dynamic-labs/embedded-wallet-bitcoin",
+  "version": "4.18.7",
+  "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
+  "author": "Dynamic Labs, Inc.",
+  "license": "MIT",
+  "main": "./src/index.cjs",
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "require": "./src/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "homepage": "https://www.dynamic.xyz/",
+  "dependencies": {
+    "@bitcoinerlab/secp256k1": "1.1.1",
+    "@dynamic-labs/bitcoin": "4.18.7",
+    "@dynamic-labs/sdk-api-core": "0.0.672",
+    "@dynamic-labs/types": "4.18.7",
+    "@dynamic-labs/utils": "4.18.7",
+    "@turnkey/http": "2.15.0",
+    "bitcoinjs-lib": "6.1.5",
+    "ecpair": "2.1.0",
+    "@dynamic-labs/assert-package-version": "4.18.7",
+    "@dynamic-labs/embedded-wallet": "4.18.7",
+    "@dynamic-labs/wallet-book": "4.18.7",
+    "@dynamic-labs/wallet-connector-core": "4.18.7"
+  },
+  "peerDependencies": {}
+}

package/src/TurnkeyBitcoinWalletConnectors.cjs

@@ -0,0 +1,23 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var embeddedWallet = require('@dynamic-labs/embedded-wallet');
+var TurnkeyBitcoinWalletConnector = require('./lib/TurnkeyBitcoinWalletConnector/TurnkeyBitcoinWalletConnector.cjs');
+
+const TurnkeyBitcoinWalletConnectors = (props) => {
+    var _a;
+    if ((_a = props === null || props === void 0 ? void 0 : props.apiProviders) === null || _a === void 0 ? void 0 : _a.turnkey) {
+        return [
+            class extends TurnkeyBitcoinWalletConnector.TurnkeyBitcoinWalletConnector {
+                constructor(innerProps) {
+                    super(embeddedWallet.TurnkeyWalletConnectorInfo.TurnkeyHD, Object.assign(Object.assign({}, props), innerProps));
+                }
+            },
+        ];
+    }
+    return [];
+};
+
+exports.TurnkeyBitcoinWalletConnectors = TurnkeyBitcoinWalletConnectors;

package/src/TurnkeyBitcoinWalletConnectors.d.ts

@@ -0,0 +1,2 @@
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+export declare const TurnkeyBitcoinWalletConnectors: (props: any) => WalletConnectorConstructor[];

package/src/TurnkeyBitcoinWalletConnectors.js

@@ -0,0 +1,19 @@
+'use client'
+import { TurnkeyWalletConnectorInfo } from '@dynamic-labs/embedded-wallet';
+import { TurnkeyBitcoinWalletConnector } from './lib/TurnkeyBitcoinWalletConnector/TurnkeyBitcoinWalletConnector.js';
+
+const TurnkeyBitcoinWalletConnectors = (props) => {
+    var _a;
+    if ((_a = props === null || props === void 0 ? void 0 : props.apiProviders) === null || _a === void 0 ? void 0 : _a.turnkey) {
+        return [
+            class extends TurnkeyBitcoinWalletConnector {
+                constructor(innerProps) {
+                    super(TurnkeyWalletConnectorInfo.TurnkeyHD, Object.assign(Object.assign({}, props), innerProps));
+                }
+            },
+        ];
+    }
+    return [];
+};
+
+export { TurnkeyBitcoinWalletConnectors };

package/src/index.cjs

@@ -0,0 +1,12 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assertPackageVersion = require('@dynamic-labs/assert-package-version');
+var _package = require('../package.cjs');
+var TurnkeyBitcoinWalletConnectors = require('./TurnkeyBitcoinWalletConnectors.cjs');
+
+assertPackageVersion.assertPackageVersion('@dynamic-labs/embedded-wallet-bitcoin', _package.version);
+
+exports.TurnkeyBitcoinWalletConnectors = TurnkeyBitcoinWalletConnectors.TurnkeyBitcoinWalletConnectors;

package/src/index.d.ts

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

package/src/index.js

@@ -0,0 +1,6 @@
+'use client'
+import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
+import { version } from '../package.js';
+export { TurnkeyBitcoinWalletConnectors } from './TurnkeyBitcoinWalletConnectors.js';
+
+assertPackageVersion('@dynamic-labs/embedded-wallet-bitcoin', version);

package/src/lib/TurnkeyBitcoinWalletConnector/TurnkeyBitcoinWalletConnector.cjs

@@ -0,0 +1,360 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var ecc = require('@bitcoinerlab/secp256k1');
+var ecpair = require('ecpair');
+var bitcoinjsLib = require('bitcoinjs-lib');
+var bitcoin = require('@dynamic-labs/bitcoin');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var utils = require('@dynamic-labs/utils');
+var embeddedWallet = require('@dynamic-labs/embedded-wallet');
+var fees = require('./fees.cjs');
+var signer = require('./signer.cjs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var ecc__default = /*#__PURE__*/_interopDefaultLegacy(ecc);
+
+bitcoinjsLib.initEccLib(ecc__default["default"]);
+class TurnkeyBitcoinWalletConnector extends embeddedWallet.TurnkeyWalletConnectorBase {
+    constructor(nameAndKey, props) {
+        super(nameAndKey, props);
+        this.ChainWallet = bitcoin.BitcoinWallet;
+        this.connectedChain = 'BTC';
+        this.supportedChains = ['BTC'];
+        this.canFetchConnectedAccounts = false;
+        this.isHardwareWalletEnabled = false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    isLedgerAddress(_address) {
+        return false;
+    }
+    clearConnectedAccounts() {
+        return Promise.resolve();
+    }
+    setVerifiedCredentials(verifiedCredentials) {
+        const turnkeyVerifiedCredentials = embeddedWallet.findTurnkeyVerifiedCredentials(verifiedCredentials, 'bip122');
+        const [turnkeyVerifiedCredential] = turnkeyVerifiedCredentials;
+        const didTurnkeyVerifiedCredentialsChanged = JSON.stringify(this.verifiedCredentials) !==
+            JSON.stringify(turnkeyVerifiedCredentials);
+        if (!didTurnkeyVerifiedCredentialsChanged) {
+            return;
+        }
+        this.verifiedCredential = turnkeyVerifiedCredential;
+        this.verifiedCredentials = turnkeyVerifiedCredentials;
+        this.refreshTurnkeyAccount();
+    }
+    validateActiveWallet(expectedAddress) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const activeAddress = ((_a = this.verifiedCredential) === null || _a === void 0 ? void 0 : _a.address) || '';
+            const isWalletActive = walletConnectorCore.isSameAddress(activeAddress, expectedAddress, this.connectedChain);
+            if (!isWalletActive) {
+                const targetActiveAccount = (_b = this.verifiedCredentials) === null || _b === void 0 ? void 0 : _b.find((vc) => (vc === null || vc === void 0 ? void 0 : vc.address) === expectedAddress);
+                if (!targetActiveAccount) {
+                    throw new utils.DynamicError('Account not found');
+                }
+                this.verifiedCredential = targetActiveAccount;
+                this.refreshTurnkeyAccount();
+            }
+        });
+    }
+    refreshTurnkeyAccount() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            this._turnkeyAccount = undefined;
+            return this.getTurnkeyAccount();
+        });
+    }
+    createTurnkeyAccount() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const turnkeyClient = yield this.getTurnkeyClient();
+            const account = turnkeyClient;
+            return account;
+        });
+    }
+    getTurnkeyAccount() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { turnkeySubOrganizationId } = (_a = this.walletProperties) !== null && _a !== void 0 ? _a : {};
+            const { address } = (_b = this.verifiedCredential) !== null && _b !== void 0 ? _b : {};
+            if (!turnkeySubOrganizationId || !address) {
+                return;
+            }
+            this._turnkeyAccount = yield this.createTurnkeyAccount();
+            this.setLoggerMetadata();
+            return this._turnkeyAccount;
+        });
+    }
+    getUTXOs(address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = bitcoin.getMempoolApiUrl(address);
+                const response = yield fetch(`${url}/address/${address}/utxo`);
+                return yield response.json();
+            }
+            catch (error) {
+                embeddedWallet.logger.error('Error fetching UTXOs:', error);
+                throw error;
+            }
+        });
+    }
+    getBitcoinNetwork(accountAddress) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return accountAddress.startsWith('t') ? bitcoinjsLib.networks.testnet : bitcoinjsLib.networks.bitcoin;
+        });
+    }
+    sendRawTransaction(rawTransaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!rawTransaction) {
+                throw new utils.DynamicError('No transaction specified!');
+            }
+            const accountAddress = this.getAccount();
+            if (!accountAddress) {
+                throw new utils.DynamicError('No account address found!');
+            }
+            const API_URL = bitcoin.getMempoolApiUrl(accountAddress);
+            const response = yield fetch(`${API_URL}/tx`, {
+                body: rawTransaction,
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                method: 'POST',
+            });
+            if (!response.ok) {
+                if (response.status === 429) {
+                    throw new utils.DynamicError('sendRawTransaction - mempool api rate limit exceeded');
+                }
+                const error = yield response.text();
+                embeddedWallet.logger.debug(`sendRawTransaction - response not ok: ${JSON.stringify(error)}`);
+                throw new utils.DynamicError('sendRawTransaction - failed to send transaction');
+            }
+            // this endpoint returns the transaction ID
+            return response.text();
+        });
+    }
+    sendBitcoin(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ recipientAddress, amount, }) {
+            var _b, _c;
+            yield this.createOrRestoreSession();
+            const accountAddress = this.getAccount();
+            const { walletAdditionalAddresses } = (_b = this.verifiedCredential) !== null && _b !== void 0 ? _b : {};
+            if (!accountAddress || !walletAdditionalAddresses) {
+                throw new Error('Failed to get address or wallet additional addresses');
+            }
+            const additionalAddress = walletAdditionalAddresses.find((additionalAddress) => additionalAddress.address === accountAddress);
+            const publicKeyCompressed = additionalAddress === null || additionalAddress === void 0 ? void 0 : additionalAddress.publicKey;
+            if (!publicKeyCompressed) {
+                throw new Error('Failed to get public key');
+            }
+            const ECPair = ecpair.ECPairFactory(ecc__default["default"]);
+            const pair = ECPair.fromPublicKey(Buffer.from(publicKeyCompressed, 'hex'));
+            const network = yield this.getBitcoinNetwork(accountAddress);
+            const psbt = new bitcoinjsLib.Psbt({ network });
+            const utxos = yield this.getUTXOs(accountAddress);
+            const feeEstimate = yield fees.estimateFees({
+                network,
+                numInputs: utxos.length,
+                numOutputs: 2,
+            });
+            const totalToSpend = utxos.reduce((total, utxo) => total + utxo.value, 0);
+            const maxToSpend = totalToSpend - feeEstimate;
+            const changeAmount = BigInt(maxToSpend) - BigInt(amount);
+            for (const utxo of utxos) {
+                if (accountAddress.startsWith('tb1p') ||
+                    accountAddress.startsWith('bc1p')) {
+                    const xOnlyPublicKey = pair.publicKey.slice(1, 33);
+                    const outputScript = bitcoinjsLib.payments.p2tr({
+                        internalPubkey: xOnlyPublicKey,
+                        network: network,
+                    }).output;
+                    if (!outputScript) {
+                        throw new Error('Failed to create output script');
+                    }
+                    psbt.addInput({
+                        hash: utxo.txid,
+                        index: utxo.vout,
+                        tapInternalKey: xOnlyPublicKey,
+                        witnessUtxo: {
+                            script: outputScript,
+                            value: utxo.value,
+                        },
+                    });
+                }
+                else {
+                    // P2WPKH (SegWit)
+                    const witnessUtxo = bitcoinjsLib.payments.p2wpkh({
+                        network,
+                        pubkey: pair.publicKey,
+                    }).output;
+                    if (!witnessUtxo) {
+                        throw new Error('Failed to create witness utxo');
+                    }
+                    psbt.addInput({
+                        hash: utxo.txid,
+                        index: utxo.vout,
+                        witnessUtxo: {
+                            script: witnessUtxo,
+                            value: utxo.value,
+                        },
+                    });
+                }
+            }
+            const DUST_LIMIT = 546; // Bitcoin's dust limit in satoshis
+            if (Number(amount) < DUST_LIMIT) {
+                throw new Error('Amount is below dust limit of 546 satoshis');
+            }
+            psbt.addOutput({
+                script: bitcoinjsLib.address.toOutputScript(recipientAddress, network),
+                value: Number(amount),
+            });
+            if (changeAmount > 0) {
+                psbt.addOutput({
+                    script: bitcoinjsLib.address.toOutputScript(accountAddress, network),
+                    value: Number(changeAmount),
+                });
+            }
+            const turnkeyClient = yield this.getTurnkeyAccount();
+            if (!turnkeyClient) {
+                throw new Error('Failed to get turnkey client');
+            }
+            const signer$1 = new signer.TurnkeySigner({
+                address: accountAddress,
+                client: turnkeyClient,
+                organizationId: (_c = this.walletProperties) === null || _c === void 0 ? void 0 : _c.turnkeySubOrganizationId,
+                publicKey: bitcoinjsLib.address.fromBech32(accountAddress).data,
+            });
+            yield Promise.all(utxos.map((_utxo, i) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                yield psbt.signInputAsync(i, signer$1);
+            })));
+            psbt.finalizeAllInputs();
+            const txHex = psbt.extractTransaction().toHex();
+            return this.sendRawTransaction(txHex);
+        });
+    }
+    signPsbt(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ allowedSighash, unsignedPsbtBase64, signature, }) {
+            var _b, _c, _d;
+            yield this.createOrRestoreSession();
+            const accountAddress = this.getAccount();
+            if (!accountAddress) {
+                throw new Error('Failed to get address');
+            }
+            const psbt = bitcoinjsLib.Psbt.fromBase64(unsignedPsbtBase64);
+            const turnkeyClient = yield this.getTurnkeyAccount();
+            if (!turnkeyClient) {
+                throw new Error('Failed to get turnkey client');
+            }
+            const signer$1 = new signer.TurnkeySigner({
+                address: accountAddress,
+                client: turnkeyClient,
+                organizationId: (_b = this.walletProperties) === null || _b === void 0 ? void 0 : _b.turnkeySubOrganizationId,
+                publicKey: bitcoinjsLib.address.fromBech32(accountAddress).data,
+            });
+            if (signature) {
+                for (let i = 0; i < signature.length; i++) {
+                    const sigIdx = (_d = (_c = signature[i]) === null || _c === void 0 ? void 0 : _c.signingIndexes) === null || _d === void 0 ? void 0 : _d[0];
+                    if (sigIdx !== undefined) {
+                        yield psbt.signInputAsync(sigIdx, signer$1, allowedSighash);
+                    }
+                }
+            }
+            else {
+                yield psbt.signAllInputsAsync(signer$1, allowedSighash);
+            }
+            psbt.finalizeAllInputs();
+            return {
+                signedPsbt: psbt.toBase64(),
+            };
+        });
+    }
+    signPsbts(requests) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const signedPsbts = yield Promise.all(requests.map((request) => this.signPsbt(request)));
+            return signedPsbts.map((response) => response.signedPsbt || '');
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    createUiTransaction(from) {
+        throw new Error('Method not implemented.');
+    }
+    canConnectWithHardwareWallet() {
+        return false;
+    }
+    isInstalledOnBrowser() {
+        return false;
+    }
+    apiGetBalance(address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const API_URL = bitcoin.getMempoolApiUrl(address);
+            const response = yield fetch(`${API_URL}/address/${address}`);
+            if (!response.ok) {
+                // if the request fails due to rate limits, return cached value
+                if (response.status === 429) {
+                    return '0';
+                }
+                // new accounts not yet indexed will return a 404
+                if (response.status === 404) {
+                    return '0';
+                }
+                return undefined;
+            }
+            const addressInfo = yield response.json();
+            if (!(addressInfo === null || addressInfo === void 0 ? void 0 : addressInfo.chain_stats) || !(addressInfo === null || addressInfo === void 0 ? void 0 : addressInfo.mempool_stats)) {
+                return undefined;
+            }
+            const confirmedBalanceInSats = Number(addressInfo.chain_stats.funded_txo_sum) -
+                Number(addressInfo.chain_stats.spent_txo_sum);
+            const unconfirmedBalanceInSats = Number(addressInfo.mempool_stats.funded_txo_sum) -
+                Number(addressInfo.mempool_stats.spent_txo_sum);
+            const balance = bitcoin.satoshisToBtc(confirmedBalanceInSats + unconfirmedBalanceInSats);
+            return balance.toString();
+        });
+    }
+    getBalance(address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.apiGetBalance(address);
+        });
+    }
+    getAccount() {
+        return this.turnkeyAddress;
+    }
+    signMessage(messageToSign, options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            yield this.createOrRestoreSession();
+            const turnkeyAccount = yield this.getTurnkeyAccount();
+            const accountAddress = this.getAccount();
+            if (!turnkeyAccount || !accountAddress) {
+                return;
+            }
+            const msgBuffer = new TextEncoder().encode(messageToSign);
+            const hashBuffer = yield crypto.subtle.digest('SHA-256', msgBuffer);
+            const hashArray = Array.from(new Uint8Array(hashBuffer));
+            const payload = hashArray
+                .map((b) => b.toString(16).padStart(2, '0'))
+                .join('');
+            const response = yield (turnkeyAccount === null || turnkeyAccount === void 0 ? void 0 : turnkeyAccount.signRawPayload({
+                organizationId: (_a = this.walletProperties) === null || _a === void 0 ? void 0 : _a.turnkeySubOrganizationId,
+                parameters: {
+                    encoding: 'PAYLOAD_ENCODING_HEXADECIMAL',
+                    hashFunction: 'HASH_FUNCTION_SHA256',
+                    payload,
+                    signWith: (_b = options === null || options === void 0 ? void 0 : options.address) !== null && _b !== void 0 ? _b : accountAddress, // default to ordinals address
+                },
+                timestampMs: new Date().getTime().toString(),
+                type: 'ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2',
+            }));
+            const result = response.activity.result.signRawPayloadResult;
+            if (!result) {
+                return;
+            }
+            const { r, s } = result;
+            return Buffer.from(r + s).toString('hex');
+        });
+    }
+}
+
+exports.TurnkeyBitcoinWalletConnector = TurnkeyBitcoinWalletConnector;

package/src/lib/TurnkeyBitcoinWalletConnector/TurnkeyBitcoinWalletConnector.d.ts

@@ -0,0 +1,47 @@
+import { networks } from 'bitcoinjs-lib';
+import { BitcoinTransaction, BitcoinWallet, BitcoinSignProtocol, BitcoinWalletStandardMethods } from '@dynamic-labs/bitcoin';
+import { GenericNetwork, IUITransaction, WalletUiUtils } from '@dynamic-labs/types';
+import { Chain, ISendBalanceWalletConnector, InternalWalletConnector, IBitcoinWalletConnector, Wallet, BitcoinSignPsbtRequest, BitcoinSignPsbtResponse } from '@dynamic-labs/wallet-connector-core';
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import { JwtVerifiedCredential } from '@dynamic-labs/sdk-api-core';
+import { TurnkeyWalletConnectorBase, TurnkeyWalletConnectorNameAndKey } from '@dynamic-labs/embedded-wallet';
+export type TurnkeyBitcoinConnectorProps = {
+    walletUiUtils: WalletUiUtils<InternalWalletConnector>;
+    walletBook: WalletBookSchema;
+    bitcoinNetworks: GenericNetwork[];
+    appName?: string;
+};
+export declare class TurnkeyBitcoinWalletConnector extends TurnkeyWalletConnectorBase implements ISendBalanceWalletConnector, IBitcoinWalletConnector {
+    ChainWallet: typeof BitcoinWallet;
+    connectedChain: Chain;
+    supportedChains: Chain[];
+    wallet: Wallet | undefined;
+    walletMethods: BitcoinWalletStandardMethods | undefined;
+    canFetchConnectedAccounts: boolean;
+    isHardwareWalletEnabled: boolean;
+    private _turnkeyAccount;
+    constructor(nameAndKey: TurnkeyWalletConnectorNameAndKey, props: TurnkeyBitcoinConnectorProps);
+    isLedgerAddress(_address: string): boolean;
+    clearConnectedAccounts(): Promise<void>;
+    setVerifiedCredentials(verifiedCredentials: JwtVerifiedCredential[]): void;
+    validateActiveWallet(expectedAddress: string): Promise<void>;
+    private refreshTurnkeyAccount;
+    private createTurnkeyAccount;
+    private getTurnkeyAccount;
+    getUTXOs(address: string): Promise<any>;
+    getBitcoinNetwork(accountAddress: string): Promise<networks.Network>;
+    sendRawTransaction(rawTransaction: string): Promise<string | undefined>;
+    sendBitcoin({ recipientAddress, amount, }: BitcoinTransaction): Promise<string | undefined>;
+    signPsbt({ allowedSighash, unsignedPsbtBase64, signature, }: BitcoinSignPsbtRequest): Promise<BitcoinSignPsbtResponse>;
+    signPsbts(requests: BitcoinSignPsbtRequest[]): Promise<string[] | undefined>;
+    createUiTransaction(from: string): Promise<IUITransaction>;
+    canConnectWithHardwareWallet(): boolean;
+    isInstalledOnBrowser(): boolean;
+    private apiGetBalance;
+    getBalance(address: string): Promise<string | undefined>;
+    getAccount(): string | undefined;
+    signMessage(messageToSign: string, options?: {
+        address?: string;
+        protocol?: BitcoinSignProtocol;
+    }): Promise<string | undefined>;
+}