@dynamic-labs-sdk/bitcoin 0.1.2 → 0.2.4

package/dist/addBitcoinInjectedWalletsExtension-DoOIj6RD.esm.js

@@ -0,0 +1,1495 @@
+import { DYNAMIC_ICONIC_SPRITE_URL, WalletProviderPriority, assertDefined, createBaseNetworkProvider, createWalletProviderEventEmitter, formatWalletProviderGroupKey, formatWalletProviderKey, getActiveNetworkIdFromLastKnownRegistry, getBuffer, getDefaultClient, getInjectedProviderFromWindow, getNetworkProviderBuilderRegistry, getWalletProviderRegistry, hasExtension, registerExtension } from "@dynamic-labs-sdk/client/core";
+import { BaseError, UserRejectedError, assertWalletAccountSigningAvailability, getNetworksData, getWalletAccountAddressByType } from "@dynamic-labs-sdk/client";
+import { WalletProviderEnum } from "@dynamic-labs/sdk-api-core";
+import { Psbt, Transaction, address, networks, payments } from "bitcoinjs-lib";
+import { createUnsecuredToken } from "jsontokens";
+import { AddressPurpose, BitcoinNetworkType, MessageSigningProtocols, RpcErrorCode, addListener, getAddress, request, sendBtcTransaction, signMessage, signMultipleTransactions, signTransaction } from "sats-connect";
+
+//#region package.json
+var name = "@dynamic-labs-sdk/bitcoin";
+var version = "0.2.4";
+
+//#endregion
+//#region src/constants.ts
+const MEMPOOL_API_URL = "https://mempool.space/api";
+const MEMPOOL_API_URL_TESTNET = "https://mempool.space/testnet/api";
+
+//#endregion
+//#region src/utils/getMempoolApiUrl/getMempoolApiUrl.ts
+const getMempoolApiUrl = (address$1) => address$1.startsWith("t") ? MEMPOOL_API_URL_TESTNET : MEMPOOL_API_URL;
+
+//#endregion
+//#region src/utils/satoshisToBtc/satoshisToBtc.ts
+const satoshisToBtc = (satoshis) => satoshis / 1e8;
+
+//#endregion
+//#region src/utils/fetchBtcBalance/fetchBtcBalance.ts
+const fetchBtcBalance = async ({ address: address$1 }) => {
+	const API_URL = getMempoolApiUrl(address$1);
+	const response = await fetch(`${API_URL}/address/${address$1}`);
+	if (!response.ok) return null;
+	const addressInfo = await response.json();
+	if (!addressInfo?.chain_stats || !addressInfo?.mempool_stats) return null;
+	return satoshisToBtc(Number(addressInfo.chain_stats.funded_txo_sum) - Number(addressInfo.chain_stats.spent_txo_sum) + (Number(addressInfo.mempool_stats.funded_txo_sum) - Number(addressInfo.mempool_stats.spent_txo_sum))).toString();
+};
+
+//#endregion
+//#region src/utils/createBitcoinNetworkProvider/createBitcoinNetworkProvider.ts
+const createBitcoinNetworkProvider = (networkData) => ({
+	...createBaseNetworkProvider("BTC", networkData),
+	cluster: networkData.cluster,
+	getBalance: async ({ address: address$1 }) => ({ balance: await fetchBtcBalance({ address: address$1 }) })
+});
+
+//#endregion
+//#region src/registerBitcoinNetworkProviderBuilder/registerBitcoinNetworkProviderBuilder.ts
+const registerBitcoinNetworkProviderBuilder = (client) => {
+	const networkProviderBuilderRegistry = getNetworkProviderBuilderRegistry(client);
+	/**
+	* If the Bitcoin network provider builder is already registered, return.
+	*/
+	if (networkProviderBuilderRegistry.get().get("BTC")) return;
+	networkProviderBuilderRegistry.register({
+		builder: createBitcoinNetworkProvider,
+		chain: "BTC"
+	});
+};
+
+//#endregion
+//#region src/errors/InvalidPsbtError.ts
+var InvalidPsbtError = class extends BaseError {
+	constructor(message) {
+		super({
+			cause: null,
+			code: "invalid_psbt_error",
+			docsUrl: null,
+			name: "InvalidPsbtError",
+			shortMessage: message
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/getSigHashType/getSigHashType.ts
+/**
+* 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 }) => {
+	if (input?.sighashType) return input.sighashType;
+	let isTaprootAddress = false;
+	if (input.witnessUtxo?.script) try {
+		payments.p2tr({ output: input.witnessUtxo.script });
+		isTaprootAddress = true;
+	} catch {}
+	return isTaprootAddress ? Transaction.SIGHASH_DEFAULT : Transaction.SIGHASH_ALL;
+};
+
+//#endregion
+//#region src/utils/validatePsbt/validateSigHash/validateSigHash.ts
+const validateSigHash = ({ allowedSigHashTypes, input }) => {
+	const sigHashType = getSigHashType({ input });
+	if (allowedSigHashTypes?.length && !allowedSigHashTypes.includes(sigHashType)) throw new InvalidPsbtError(`sigHashType ${sigHashType} not in allowed list`);
+};
+
+//#endregion
+//#region src/utils/validatePsbt/extractAddressFromInput/extractAddressFromInput.ts
+/**
+* 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 = ({ index, input, psbt }) => {
+	let extractedAddress;
+	try {
+		if (input.witnessUtxo?.script) extractedAddress = address.fromOutputScript(input.witnessUtxo.script);
+		if (input.nonWitnessUtxo) {
+			const txOut = Transaction.fromBuffer(input.nonWitnessUtxo).outs[psbt.txInputs[index].index];
+			extractedAddress = address.fromOutputScript(txOut.script);
+		}
+		return extractedAddress;
+	} catch {
+		return extractedAddress;
+	}
+};
+
+//#endregion
+//#region src/utils/validatePsbt/validateSigningAddress/validateSigningAddress.ts
+const validateSigningAddress = ({ index, inputAtIndex, psbt, signingAddress }) => {
+	const extractedAddress = extractAddressFromInput({
+		index,
+		input: inputAtIndex,
+		psbt
+	});
+	if (!extractedAddress) throw new InvalidPsbtError(`Could not extract address from input at index ${index}`);
+	if (extractedAddress !== signingAddress) throw new InvalidPsbtError(`Signing address does not match with address extracted from input at index ${index}`);
+};
+
+//#endregion
+//#region src/utils/validatePsbt/validatePsbt.ts
+/**
+* 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 = ({ allowedSigHashTypes, psbt, signatureData }) => {
+	if (!signatureData?.length) return;
+	for (const input of signatureData) {
+		const { address: signingAddress, signingIndexes, disableAddressValidation = true } = input;
+		if (!signingIndexes?.length) return;
+		if (!signingAddress) throw new InvalidPsbtError("Missing signing address");
+		for (const index of signingIndexes) {
+			const inputAtIndex = psbt.data.inputs[index];
+			if (!inputAtIndex) throw new InvalidPsbtError(`Missing input for index ${index}`);
+			if (!disableAddressValidation) validateSigningAddress({
+				index,
+				inputAtIndex,
+				psbt,
+				signingAddress
+			});
+			validateSigHash({
+				allowedSigHashTypes,
+				input: inputAtIndex
+			});
+		}
+	}
+};
+
+//#endregion
+//#region src/utils/createPsbtOptions/createPsbtOptions.ts
+/**
+* This method will create the psbt sign options for the given request
+* It will validate the psbt against the signature data provided in the request
+* It will return the psbt sign options with the toSignInputs added if the signature data is provided
+*/
+const createPsbtOptions = ({ psbt, request: request$1 }) => {
+	const psbtSignOptions = { autoFinalized: false };
+	if (!request$1.signature) return psbtSignOptions;
+	validatePsbt({
+		allowedSigHashTypes: request$1.allowedSighash,
+		psbt,
+		signatureData: request$1.signature
+	});
+	const toSignInputs = [];
+	for (const signature of request$1.signature) if (signature.signingIndexes?.length) for (const index of signature.signingIndexes) toSignInputs.push({
+		address: signature.address,
+		disableAddressValidation: signature.disableAddressValidation,
+		index,
+		sighashTypes: request$1.allowedSighash
+	});
+	psbtSignOptions.toSignInputs = toSignInputs;
+	return psbtSignOptions;
+};
+
+//#endregion
+//#region src/utils/getNetworkIdFromNetworkName/getNetworkIdFromNetworkName.ts
+const getNetworkIdFromNetworkName = ({ networkName }, client) => {
+	return { networkId: getNetworksData(client).filter((data) => data.chain === "BTC").find((data) => data.cluster === networkName)?.networkId ?? "1" };
+};
+
+//#endregion
+//#region src/injected/utils/binance/createBinanceBitcoinWalletProvider/createBinanceBitcoinWalletProvider.ts
+const BINANCE_METADATA = {
+	displayName: "Binance Wallet",
+	icon: `${DYNAMIC_ICONIC_SPRITE_URL}#onekey`
+};
+const createBinanceBitcoinWalletProvider = ({ dynamicClient, injectedProvider }) => {
+	const chain = "BTC";
+	const walletProviderType = WalletProviderEnum.BrowserExtension;
+	const key = formatWalletProviderKey({
+		chain,
+		displayName: BINANCE_METADATA.displayName,
+		walletProviderType
+	});
+	const connect = async () => {
+		return { addresses: [{
+			address: (await injectedProvider.requestAccounts())[0],
+			publicKey: await injectedProvider.getPublicKey()
+		}] };
+	};
+	const getActiveNetworkId = async () => {
+		return getNetworkIdFromNetworkName({ networkName: await injectedProvider.getNetwork() }, dynamicClient);
+	};
+	const getConnectedAddresses = async () => {
+		return { addresses: await injectedProvider.getAccounts() };
+	};
+	const signMessage$1 = async ({ message, walletAccount, protocol }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		return { signature: await injectedProvider.signMessage(message, protocol) };
+	};
+	const signPsbt = async ({ request: request$1, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const psbtFromBase64 = Psbt.fromBase64(request$1.unsignedPsbtBase64);
+		const psbtOptions = createPsbtOptions({
+			psbt: psbtFromBase64,
+			request: request$1
+		});
+		const signedPsbtHex = await injectedProvider.signPsbt(psbtFromBase64.toHex(), {
+			autoFinalized: false,
+			toSignInputs: psbtOptions.toSignInputs || []
+		});
+		return { signedPsbt: Psbt.fromHex(signedPsbtHex).toBase64() };
+	};
+	const signPsbts = async ({ requests, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const signedPsbts = [];
+		for (const request$1 of requests) {
+			const signedPsbtResponse = await signPsbt({
+				request: request$1,
+				walletAccount
+			});
+			if (signedPsbtResponse) signedPsbts.push(signedPsbtResponse.signedPsbt);
+		}
+		return { signedPsbts };
+	};
+	const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
+		removeEventListeners: () => {
+			injectedProvider?.removeAllListeners();
+		},
+		setupEventListeners: ({ handleAccountsChanged, handleNetworkChanged }) => {
+			injectedProvider?.on("accountsChanged", (addresses) => {
+				handleAccountsChanged({ addresses });
+			});
+			injectedProvider?.on("networkChanged", (network) => {
+				handleNetworkChanged({ networkId: network });
+			});
+		},
+		supportedEvents: ["accountsChanged", "networkChanged"]
+	});
+	const terminate = async () => {
+		cleanupEventEmitter();
+	};
+	return {
+		chain,
+		connect,
+		get events() {
+			return getEventEmitter();
+		},
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: formatWalletProviderGroupKey(BINANCE_METADATA.displayName),
+		key,
+		metadata: BINANCE_METADATA,
+		signMessage: signMessage$1,
+		signPsbt,
+		signPsbts,
+		terminate,
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/injected/utils/binance/getBinanceBitcoinInjectedProvider/getBinanceBitcoinInjectedProvider.ts
+const BINANCE_BITCOIN_PROVIDER_LOCATOR = "binancew3w.bitcoin";
+const getBinanceBitcoinInjectedProvider = () => {
+	return getInjectedProviderFromWindow(BINANCE_BITCOIN_PROVIDER_LOCATOR);
+};
+
+//#endregion
+//#region src/injected/utils/unisat/createUnisatWalletProvider/createUnisatWalletProvider.ts
+const UNISAT_METADATA = {
+	displayName: "UniSat",
+	icon: `${DYNAMIC_ICONIC_SPRITE_URL}#unisat`
+};
+const createUnisatWalletProvider = ({ dynamicClient, injectedProvider }) => {
+	const chain = "BTC";
+	const walletProviderType = WalletProviderEnum.BrowserExtension;
+	const key = formatWalletProviderKey({
+		chain,
+		displayName: UNISAT_METADATA.displayName,
+		walletProviderType
+	});
+	const connect = async () => {
+		return { addresses: (await injectedProvider.requestAccounts()).map((address$1) => ({ address: address$1 })) };
+	};
+	const disconnect = async () => {
+		return injectedProvider.disconnect();
+	};
+	const getActiveNetworkId = async () => {
+		const chain$1 = await injectedProvider.getChain();
+		let networkName = "mainnet";
+		if (chain$1.enum === "BITCOIN_TESTNET") networkName = "testnet";
+		else if (chain$1.enum === "BITCOIN_SIGNET") networkName = "signet";
+		return getNetworkIdFromNetworkName({ networkName }, dynamicClient);
+	};
+	const getConnectedAddresses = async () => {
+		return { addresses: await injectedProvider.getAccounts() };
+	};
+	const sendBitcoin = async ({ transaction, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		return { transactionId: await injectedProvider.sendBitcoin(transaction.recipientAddress, Number(transaction.amount)) };
+	};
+	const signMessage$1 = async ({ message, walletAccount, protocol }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		return { signature: await injectedProvider.signMessage(message, protocol) };
+	};
+	const signPsbt = async ({ request: request$1, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const psbtFromBase64 = Psbt.fromBase64(request$1.unsignedPsbtBase64);
+		const signedPsbtHex = await injectedProvider.signPsbt(psbtFromBase64.toHex(), createPsbtOptions({
+			psbt: psbtFromBase64,
+			request: request$1
+		}));
+		return { signedPsbt: Psbt.fromHex(signedPsbtHex).toBase64() };
+	};
+	const signPsbts = async ({ requests, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const psbtHexs = [];
+		const psbtOptions = [];
+		for (const request$1 of requests) {
+			const psbtFromBase64 = Psbt.fromBase64(request$1.unsignedPsbtBase64);
+			psbtHexs.push(psbtFromBase64.toHex());
+			psbtOptions.push(createPsbtOptions({
+				psbt: psbtFromBase64,
+				request: request$1
+			}));
+		}
+		return { signedPsbts: (await injectedProvider.signPsbts(psbtHexs, psbtOptions)).map((signedPsbtHex) => Psbt.fromHex(signedPsbtHex).toBase64()) };
+	};
+	const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
+		removeEventListeners: () => {
+			injectedProvider?.removeAllListeners();
+		},
+		setupEventListeners: ({ handleAccountsChanged, handleNetworkChanged }) => {
+			injectedProvider?.on("accountsChanged", (addresses) => {
+				handleAccountsChanged({ addresses });
+			});
+			injectedProvider?.on("networkChanged", (network) => {
+				handleNetworkChanged({ networkId: network });
+			});
+		},
+		supportedEvents: ["accountsChanged", "networkChanged"]
+	});
+	const terminate = async () => {
+		cleanupEventEmitter();
+	};
+	return {
+		chain,
+		connect,
+		disconnect,
+		get events() {
+			return getEventEmitter();
+		},
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: formatWalletProviderGroupKey(UNISAT_METADATA.displayName),
+		key,
+		metadata: UNISAT_METADATA,
+		sendBitcoin,
+		signMessage: signMessage$1,
+		signPsbt,
+		signPsbts,
+		terminate,
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/injected/utils/bitget/createBitgetBitcoinWalletProvider/createBitgetBitcoinWalletProvider.ts
+const BITGET_METADATA = {
+	displayName: "Bitget Wallet",
+	icon: `${DYNAMIC_ICONIC_SPRITE_URL}#bitgetwallet`
+};
+const createBitgetBitcoinWalletProvider = ({ dynamicClient, injectedProvider }) => {
+	const unisatWalletProvider = createUnisatWalletProvider({
+		dynamicClient,
+		injectedProvider
+	});
+	return {
+		...unisatWalletProvider,
+		groupKey: formatWalletProviderGroupKey(BITGET_METADATA.displayName),
+		key: formatWalletProviderKey({
+			chain: unisatWalletProvider.chain,
+			displayName: BITGET_METADATA.displayName,
+			walletProviderType: unisatWalletProvider.walletProviderType
+		}),
+		metadata: BITGET_METADATA
+	};
+};
+
+//#endregion
+//#region src/injected/utils/bitget/getBitgetBitcoinInjectedProvider/getBitgetBitcoinInjectedProvider.ts
+const BITGET_BITCOIN_PROVIDER_LOCATOR = "bitkeep.unisat";
+const getBitgetBitcoinInjectedProvider = () => {
+	return getInjectedProviderFromWindow(BITGET_BITCOIN_PROVIDER_LOCATOR);
+};
+
+//#endregion
+//#region src/utils/convertNetworkIdForPsbt/convertNetworkIdForPsbt.ts
+const convertNetworkIdForPsbt = (networkId) => {
+	if (networkId === "1") return networks.bitcoin;
+	if (networkId === "2" || networkId === "3") return networks.testnet;
+};
+
+//#endregion
+//#region src/injected/utils/leather/convertNetworkIdToLeatherNetworkName/convertNetworkIdToLeatherNetworkName.ts
+const convertNetworkIdToLeatherNetworkName = (networkId) => {
+	if (networkId === "1") return "mainnet";
+	if (networkId === "2") return "testnet";
+	if (networkId === "3") return "signet";
+};
+
+//#endregion
+//#region src/injected/utils/leather/createLeatherBitcoinWalletProvider/createLeatherBitcoinWalletProvider.ts
+const LEATHER_METADATA = {
+	displayName: "Leather",
+	icon: `${DYNAMIC_ICONIC_SPRITE_URL}#leather`
+};
+const createLeatherBitcoinWalletProvider = ({ dynamicClient, injectedProvider }) => {
+	const chain = "BTC";
+	const walletProviderType = WalletProviderEnum.BrowserExtension;
+	const key = formatWalletProviderKey({
+		chain,
+		displayName: LEATHER_METADATA.displayName,
+		walletProviderType
+	});
+	const getNetworkPayload = async () => {
+		const { networkId } = await getActiveNetworkId();
+		return {
+			networkId,
+			networkName: convertNetworkIdToLeatherNetworkName(networkId)
+		};
+	};
+	const connect = async () => {
+		const connectedAddresses = (await injectedProvider.request("getAddresses").catch(({ error }) => {
+			throw error;
+		})).result.addresses;
+		const addresses = [];
+		const ordinalsAddress = connectedAddresses?.find((address$1) => address$1.type === "p2tr");
+		if (ordinalsAddress) addresses.push({
+			address: ordinalsAddress.address,
+			publicKey: ordinalsAddress.publicKey,
+			type: "ordinals"
+		});
+		const paymentAddress = connectedAddresses?.find((address$1) => address$1.type === "p2wpkh");
+		if (paymentAddress) addresses.push({
+			address: paymentAddress.address,
+			publicKey: paymentAddress.publicKey,
+			type: "payment"
+		});
+		return { addresses };
+	};
+	const getActiveNetworkId = async () => getActiveNetworkIdFromLastKnownRegistry({
+		client: dynamicClient,
+		walletProviderKey: key
+	});
+	const getConnectedAddresses = async () => {
+		return { addresses: (await connect()).addresses.map((address$1) => address$1.address) };
+	};
+	const sendBitcoin = async ({ transaction }) => {
+		const { networkName } = await getNetworkPayload();
+		return { transactionId: (await injectedProvider.request("sendTransfer", {
+			account: 0,
+			address: transaction.recipientAddress,
+			amount: transaction.amount.toString(),
+			network: networkName ?? "mainnet"
+		}).catch(({ error }) => {
+			throw error;
+		})).result.txid };
+	};
+	const signMessage$1 = async ({ message, walletAccount, addressType }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		let paymentType = "p2tr";
+		if (addressType === "payment") paymentType = "p2wpkh";
+		const { networkName } = await getNetworkPayload();
+		return { signature: (await injectedProvider.request("signMessage", {
+			message,
+			network: networkName,
+			paymentType
+		}).catch(({ error }) => {
+			throw error;
+		})).result.signature };
+	};
+	const signPsbt = async ({ request: request$1 }) => {
+		const { networkId, networkName } = await getNetworkPayload();
+		const psbtNetwork = convertNetworkIdForPsbt(networkId);
+		const psbtFromBase64 = Psbt.fromBase64(request$1.unsignedPsbtBase64, { network: psbtNetwork });
+		const signAtIndex = request$1.signature?.flatMap((sig) => sig.signingIndexes).filter(Number.isInteger);
+		const signedPsbtHex = (await injectedProvider.request("signPsbt", {
+			account: 0,
+			allowedSighash: request$1.allowedSighash,
+			broadcast: false,
+			hex: psbtFromBase64.toHex(),
+			network: networkName ?? "mainnet",
+			signAtIndex
+		}).catch(({ error }) => {
+			throw error;
+		})).result.hex;
+		return { signedPsbt: Psbt.fromHex(signedPsbtHex, { network: psbtNetwork }).toBase64() };
+	};
+	const signPsbts = async ({ requests, walletAccount }) => {
+		const signedPsbts = [];
+		for (const request$1 of requests) {
+			const signedPsbtResponse = await signPsbt({
+				request: request$1,
+				walletAccount
+			});
+			if (signedPsbtResponse) signedPsbts.push(signedPsbtResponse.signedPsbt);
+		}
+		return { signedPsbts };
+	};
+	return {
+		chain,
+		connect,
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: formatWalletProviderGroupKey(LEATHER_METADATA.displayName),
+		key,
+		metadata: LEATHER_METADATA,
+		sendBitcoin,
+		signMessage: signMessage$1,
+		signPsbt,
+		signPsbts,
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/injected/utils/leather/getLeatherBitcoinInjectedProvider/getLeatherBitcoinInjectedProvider.ts
+const LEATHER_BITCOIN_PROVIDER_LOCATOR = "LeatherProvider";
+const getLeatherBitcoinInjectedProvider = () => {
+	return getInjectedProviderFromWindow(LEATHER_BITCOIN_PROVIDER_LOCATOR);
+};
+
+//#endregion
+//#region src/utils/convertNetworkIdToSatsConnectNetworkType/convertNetworkIdToSatsConnectNetworkType.ts
+const convertNetworkIdToSatsConnectNetworkType = (networkId) => {
+	if (networkId === "2") return BitcoinNetworkType.Testnet;
+	if (networkId === "3") return BitcoinNetworkType.Signet;
+	return BitcoinNetworkType.Mainnet;
+};
+
+//#endregion
+//#region src/utils/getPsbtInputsToSignForSatsConnect/getPsbtInputsToSignForSatsConnect.ts
+/**
+* This method will create the psbt sign options for SatsConnect for the given request
+* It will validate the psbt against the signature data provided in the request
+* It will return the inputs to sign if the signature data is provided
+*/
+const getPsbtInputsToSignForSatsConnect = ({ psbt, request: request$1, isLegacySatsConnect }) => {
+	if (!request$1.signature) return [];
+	validatePsbt({
+		allowedSigHashTypes: request$1.allowedSighash,
+		psbt,
+		signatureData: request$1.signature
+	});
+	const inputsToSign = [];
+	for (const signature of request$1.signature) if (signature.signingIndexes?.length) for (const index of signature.signingIndexes) inputsToSign.push({
+		address: signature.address,
+		sigHash: isLegacySatsConnect ? getSigHashType({ input: psbt.data.inputs[index] }) : request$1.allowedSighash[0],
+		signingIndexes: [index]
+	});
+	return inputsToSign;
+};
+
+//#endregion
+//#region src/utils/getSatsConnectSigningProtocol/getSatsConnectSigningProtocol.ts
+const getSatsConnectSigningProtocol = (protocol) => {
+	if (!protocol) return;
+	return protocol === "ecdsa" ? MessageSigningProtocols.ECDSA : MessageSigningProtocols.BIP322;
+};
+
+//#endregion
+//#region src/utils/parseBitcoinConnectionResult/parseBitcoinConnectionResult.ts
+const parseBitcoinConnectionResult = ({ connectedAddresses }) => {
+	const addresses = connectedAddresses.filter((address$1) => address$1.purpose === "ordinals" || address$1.purpose === "payment").map((account) => ({
+		address: account.address,
+		publicKey: account.publicKey,
+		type: account.purpose === "payment" ? "payment" : "ordinals"
+	}));
+	addresses.sort((a) => a.type === "ordinals" ? -1 : 1);
+	return { addresses };
+};
+
+//#endregion
+//#region src/injected/utils/magicEden/createMagicEdenBitcoinWalletProvider/createMagicEdenBitcoinWalletProvider.ts
+const MAGIC_EDEN_METADATA = {
+	displayName: "Magic Eden",
+	icon: `${DYNAMIC_ICONIC_SPRITE_URL}#magiceden`
+};
+const createMagicEdenBitcoinWalletProvider = ({ dynamicClient, satsConnectProvider }) => {
+	const chain = "BTC";
+	const walletProviderType = WalletProviderEnum.BrowserExtension;
+	const key = formatWalletProviderKey({
+		chain,
+		displayName: MAGIC_EDEN_METADATA.displayName,
+		walletProviderType
+	});
+	const getNetworkPayload = async () => {
+		return { network: { type: convertNetworkIdToSatsConnectNetworkType((await getActiveNetworkId()).networkId) } };
+	};
+	const connect = async () => {
+		const { network } = await getNetworkPayload();
+		return new Promise((resolve, reject) => {
+			getAddress({
+				getProvider: async () => satsConnectProvider,
+				onCancel: () => {
+					reject(new UserRejectedError({ action: "connect" }));
+				},
+				onFinish: async (response) => {
+					const { addresses: connectedAddresses } = response;
+					const { addresses } = parseBitcoinConnectionResult({ connectedAddresses });
+					resolve({ addresses });
+				},
+				payload: {
+					message: "Address for receiving Ordinals and payments",
+					network,
+					purposes: [AddressPurpose.Ordinals, AddressPurpose.Payment]
+				}
+			});
+		});
+	};
+	const getActiveNetworkId = async () => getActiveNetworkIdFromLastKnownRegistry({
+		client: dynamicClient,
+		walletProviderKey: key
+	});
+	const getConnectedAddresses = async () => {
+		const { addresses } = await connect();
+		return { addresses: addresses.map((address$1) => address$1.address) };
+	};
+	const sendBitcoin = async ({ transaction, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const senderAddress = getWalletAccountAddressByType({
+			type: "payment",
+			walletAccount
+		}) ?? walletAccount.address;
+		const { network } = await getNetworkPayload();
+		return new Promise((resolve, reject) => {
+			sendBtcTransaction({
+				getProvider: async () => satsConnectProvider,
+				onCancel: () => {
+					reject(new UserRejectedError({ action: "sendBitcoin" }));
+				},
+				onFinish: (response) => {
+					resolve({ transactionId: response });
+				},
+				payload: {
+					network,
+					recipients: [{
+						address: transaction.recipientAddress,
+						amountSats: BigInt(transaction.amount)
+					}],
+					senderAddress
+				}
+			});
+		});
+	};
+	const signMessage$1 = async ({ message, walletAccount, protocol, addressType }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const { network } = await getNetworkPayload();
+		let addressToSignWith = walletAccount.address;
+		if (addressType) addressToSignWith = getWalletAccountAddressByType({
+			type: addressType,
+			walletAccount
+		}) ?? addressToSignWith;
+		return new Promise((resolve, reject) => {
+			signMessage({
+				getProvider: async () => satsConnectProvider,
+				onCancel: () => {
+					reject(new UserRejectedError({ action: "signMessage" }));
+				},
+				onFinish: async (response) => {
+					resolve({ signature: response });
+				},
+				payload: {
+					address: addressToSignWith,
+					message,
+					network,
+					protocol: getSatsConnectSigningProtocol(protocol)
+				}
+			});
+		});
+	};
+	const signPsbt = async ({ request: request$1, walletAccount }) => {
+		if (!request$1.allowedSighash.length) throw new InvalidPsbtError("allowedSighash cannot be an empty array");
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const network = convertNetworkIdForPsbt((await getActiveNetworkId()).networkId);
+		const { network: networkPayload } = await getNetworkPayload();
+		const inputsToSign = getPsbtInputsToSignForSatsConnect({
+			isLegacySatsConnect: true,
+			psbt: Psbt.fromBase64(request$1.unsignedPsbtBase64, { network }),
+			request: request$1
+		});
+		return new Promise((resolve, reject) => {
+			signTransaction({
+				getProvider: async () => satsConnectProvider,
+				onCancel: () => {
+					reject(new UserRejectedError({ action: "signPsbt" }));
+				},
+				onFinish: (response) => {
+					resolve({ signedPsbt: response.psbtBase64 });
+				},
+				payload: {
+					broadcast: false,
+					inputsToSign,
+					message: "Sign Pbst",
+					network: networkPayload,
+					psbtBase64: request$1.unsignedPsbtBase64
+				}
+			});
+		});
+	};
+	const signPsbts = async ({ requests, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const network = convertNetworkIdForPsbt((await getActiveNetworkId()).networkId);
+		const { network: networkPayload } = await getNetworkPayload();
+		const psbtsToSign = [];
+		for (const request$2 of requests) {
+			const inputsToSign = getPsbtInputsToSignForSatsConnect({
+				isLegacySatsConnect: true,
+				psbt: Psbt.fromBase64(request$2.unsignedPsbtBase64, { network }),
+				request: request$2
+			});
+			psbtsToSign.push({
+				inputsToSign,
+				psbtBase64: request$2.unsignedPsbtBase64
+			});
+		}
+		const request$1 = createUnsecuredToken({
+			message: "Sign Pbsts",
+			network: networkPayload,
+			psbts: psbtsToSign
+		});
+		return { signedPsbts: (await satsConnectProvider.signMultipleTransactions(request$1)).map((response) => response.psbtBase64) };
+	};
+	const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
+		removeEventListeners: ({ setupReturnValue }) => {
+			assertDefined(setupReturnValue, "Setup return value not defined");
+			setupReturnValue.removeAccountChangeListener();
+		},
+		setupEventListeners: ({ handleAccountsChanged }) => {
+			return { removeAccountChangeListener: addListener("accountsChanged", (accounts) => {
+				if (!accounts) return;
+				handleAccountsChanged({ addresses: accounts.map((account) => account.address) });
+			}) };
+		},
+		supportedEvents: ["accountsChanged"]
+	});
+	const terminate = async () => {
+		cleanupEventEmitter();
+	};
+	return {
+		chain,
+		connect,
+		get events() {
+			return getEventEmitter();
+		},
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: formatWalletProviderGroupKey(MAGIC_EDEN_METADATA.displayName),
+		key,
+		metadata: MAGIC_EDEN_METADATA,
+		sendBitcoin,
+		signMessage: signMessage$1,
+		signPsbt,
+		signPsbts,
+		terminate,
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/injected/utils/magicEden/getMagicEdenInjectedProvider/getMagicEdenInjectedProvider.ts
+const MAGIC_EDEN_BITCOIN_PROVIDER_LOCATOR = "magicEden.bitcoin";
+const getMagicEdenInjectedProvider = () => {
+	return getInjectedProviderFromWindow(MAGIC_EDEN_BITCOIN_PROVIDER_LOCATOR);
+};
+
+//#endregion
+//#region src/injected/utils/okx/createOkxBitcoinWalletProvider/createOkxBitcoinWalletProvider.ts
+const OKX_METADATA = {
+	displayName: "OKX Wallet",
+	icon: `${DYNAMIC_ICONIC_SPRITE_URL}#okx`
+};
+const createOkxBitcoinWalletProvider = ({ dynamicClient, injectedProvider }) => {
+	const chain = "BTC";
+	const walletProviderType = WalletProviderEnum.BrowserExtension;
+	const key = formatWalletProviderKey({
+		chain,
+		displayName: OKX_METADATA.displayName,
+		walletProviderType
+	});
+	const connect = async () => {
+		const { address: address$1, publicKey } = await injectedProvider.connect();
+		return { addresses: [{
+			address: address$1,
+			publicKey
+		}] };
+	};
+	const getActiveNetworkId = async () => {
+		return getNetworkIdFromNetworkName({ networkName: await injectedProvider.getNetwork() }, dynamicClient);
+	};
+	const getConnectedAddresses = async () => {
+		return { addresses: await injectedProvider.getAccounts() };
+	};
+	const sendBitcoin = async ({ transaction, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		return { transactionId: await injectedProvider.sendBitcoin(transaction.recipientAddress, transaction.amount.toString()) };
+	};
+	const signMessage$1 = async ({ message, walletAccount, protocol }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		return { signature: await injectedProvider.signMessage(message, protocol) };
+	};
+	const signPsbt = async ({ request: request$1, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const psbtFromBase64 = Psbt.fromBase64(request$1.unsignedPsbtBase64);
+		const signedPsbtHex = await injectedProvider.signPsbt(psbtFromBase64.toHex(), createPsbtOptions({
+			psbt: psbtFromBase64,
+			request: request$1
+		}));
+		return { signedPsbt: Psbt.fromHex(signedPsbtHex).toBase64() };
+	};
+	const signPsbts = async ({ requests, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const psbtHexs = [];
+		const psbtOptions = [];
+		for (const request$1 of requests) {
+			const psbtFromBase64 = Psbt.fromBase64(request$1.unsignedPsbtBase64);
+			psbtHexs.push(psbtFromBase64.toHex());
+			psbtOptions.push(createPsbtOptions({
+				psbt: psbtFromBase64,
+				request: request$1
+			}));
+		}
+		return { signedPsbts: (await injectedProvider.signPsbts(psbtHexs, psbtOptions)).map((signedPsbtHex) => Psbt.fromHex(signedPsbtHex).toBase64()) };
+	};
+	const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
+		removeEventListeners: () => {
+			injectedProvider?.removeAllListeners();
+		},
+		setupEventListeners: ({ handleAccountsChanged }) => {
+			injectedProvider?.on("accountsChanged", (addresses) => {
+				handleAccountsChanged({ addresses });
+			});
+		},
+		supportedEvents: ["accountsChanged"]
+	});
+	const terminate = async () => {
+		cleanupEventEmitter();
+	};
+	return {
+		chain,
+		connect,
+		get events() {
+			return getEventEmitter();
+		},
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: formatWalletProviderGroupKey(OKX_METADATA.displayName),
+		key,
+		metadata: OKX_METADATA,
+		sendBitcoin,
+		signMessage: signMessage$1,
+		signPsbt,
+		signPsbts,
+		terminate,
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/injected/utils/okx/getOkxBitcoinInjectedProvider/getOkxBitcoinInjectedProvider.ts
+const OKX_BITCOIN_PROVIDER_LOCATOR = "okxwallet.bitcoin";
+const getOkxBitcoinInjectedProvider = () => {
+	return getInjectedProviderFromWindow(OKX_BITCOIN_PROVIDER_LOCATOR);
+};
+
+//#endregion
+//#region src/injected/utils/oneKey/createOneKeyBitcoinWalletProvider/createOneKeyBitcoinWalletProvider.ts
+const ONEKEY_METADATA = {
+	displayName: "OneKey",
+	icon: `${DYNAMIC_ICONIC_SPRITE_URL}#onekey`
+};
+const createOneKeyBitcoinWalletProvider = ({ dynamicClient, injectedProvider }) => {
+	const chain = "BTC";
+	const walletProviderType = WalletProviderEnum.BrowserExtension;
+	const key = formatWalletProviderKey({
+		chain,
+		displayName: ONEKEY_METADATA.displayName,
+		walletProviderType
+	});
+	const connect = async () => {
+		return { addresses: [{
+			address: (await injectedProvider.requestAccounts())[0],
+			publicKey: await injectedProvider.getPublicKey()
+		}] };
+	};
+	const getActiveNetworkId = async () => {
+		return getNetworkIdFromNetworkName({ networkName: await injectedProvider.getNetwork() }, dynamicClient);
+	};
+	const getConnectedAddresses = async () => {
+		return { addresses: await injectedProvider.getAccounts() };
+	};
+	const sendBitcoin = async ({ transaction, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		return { transactionId: await injectedProvider.sendBitcoin(transaction.recipientAddress, transaction.amount.toString()) };
+	};
+	const signMessage$1 = async ({ message, walletAccount, protocol }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		return { signature: await injectedProvider.signMessage(message, protocol) };
+	};
+	const signPsbt = async ({ request: request$1, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const psbtFromBase64 = Psbt.fromBase64(request$1.unsignedPsbtBase64);
+		const signedPsbtHex = await injectedProvider.signPsbt(psbtFromBase64.toHex(), { autoFinalized: false });
+		return { signedPsbt: Psbt.fromHex(signedPsbtHex).toBase64() };
+	};
+	const signPsbts = async ({ requests, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const psbtHexs = [];
+		for (const request$1 of requests) {
+			const psbtFromBase64 = Psbt.fromBase64(request$1.unsignedPsbtBase64);
+			psbtHexs.push(psbtFromBase64.toHex());
+		}
+		return { signedPsbts: (await injectedProvider.signPsbts(psbtHexs, { autoFinalized: false })).map((signedPsbtHex) => Psbt.fromHex(signedPsbtHex).toBase64()) };
+	};
+	const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
+		removeEventListeners: () => {
+			injectedProvider?.removeAllListeners();
+		},
+		setupEventListeners: ({ handleAccountsChanged, handleNetworkChanged }) => {
+			injectedProvider?.on("accountsChanged", (addresses) => {
+				handleAccountsChanged({ addresses });
+			});
+			injectedProvider?.on("networkChanged", (network) => {
+				handleNetworkChanged({ networkId: network });
+			});
+		},
+		supportedEvents: ["accountsChanged", "networkChanged"]
+	});
+	const terminate = async () => {
+		cleanupEventEmitter();
+	};
+	return {
+		chain,
+		connect,
+		get events() {
+			return getEventEmitter();
+		},
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: formatWalletProviderGroupKey(ONEKEY_METADATA.displayName),
+		key,
+		metadata: ONEKEY_METADATA,
+		sendBitcoin,
+		signMessage: signMessage$1,
+		signPsbt,
+		signPsbts,
+		terminate,
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/injected/utils/oneKey/getOneKeyBitcoinInjectedProvider/getOneKeyBitcoinInjectedProvider.ts
+const ONEKEY_BITCOIN_PROVIDER_LOCATOR = "$onekey.btc";
+const getOneKeyBitcoinInjectedProvider = () => {
+	return getInjectedProviderFromWindow(ONEKEY_BITCOIN_PROVIDER_LOCATOR);
+};
+
+//#endregion
+//#region src/injected/utils/oyl/createOylBitcoinWalletProvider/createOylBitcoinWalletProvider.ts
+const OYL_METADATA = {
+	displayName: "Oyl Wallet",
+	icon: `${DYNAMIC_ICONIC_SPRITE_URL}#oyl`
+};
+const createOylBitcoinWalletProvider = ({ dynamicClient, injectedProvider }) => {
+	const chain = "BTC";
+	const walletProviderType = WalletProviderEnum.BrowserExtension;
+	const key = formatWalletProviderKey({
+		chain,
+		displayName: OYL_METADATA.displayName,
+		walletProviderType
+	});
+	const connect = async () => {
+		const connectedAddresses = await injectedProvider.getAddresses();
+		const addresses = [];
+		const ordinalsAddress = connectedAddresses.taproot;
+		if (ordinalsAddress) addresses.push({
+			address: ordinalsAddress.address,
+			publicKey: ordinalsAddress.publicKey,
+			type: "ordinals"
+		});
+		const paymentAddress = connectedAddresses.nativeSegwit;
+		if (paymentAddress) addresses.push({
+			address: paymentAddress.address,
+			publicKey: paymentAddress.publicKey,
+			type: "payment"
+		});
+		return { addresses };
+	};
+	const getActiveNetworkId = async () => {
+		return getNetworkIdFromNetworkName({ networkName: await injectedProvider.getNetwork() }, dynamicClient);
+	};
+	const getConnectedAddresses = async () => {
+		if (!await injectedProvider.isConnected()) return { addresses: [] };
+		const { addresses } = await connect();
+		return { addresses: addresses.map((address$1) => address$1.address) };
+	};
+	const signMessage$1 = async ({ message, walletAccount, addressType, protocol }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		let addressToSignWith = walletAccount.address;
+		if (addressType) addressToSignWith = getWalletAccountAddressByType({
+			type: addressType,
+			walletAccount
+		}) ?? addressToSignWith;
+		return { signature: (await injectedProvider.signMessage({
+			address: addressToSignWith,
+			message,
+			protocol: protocol === "bip322-simple" ? "bip322" : protocol
+		})).signature };
+	};
+	const signPsbt = async ({ request: request$1, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const psbtFromBase64 = Psbt.fromBase64(request$1.unsignedPsbtBase64);
+		const { psbt: signedPsbtHex } = await injectedProvider.signPsbt({
+			broadcast: false,
+			finalize: false,
+			psbt: psbtFromBase64.toHex()
+		});
+		return { signedPsbt: Psbt.fromHex(signedPsbtHex).toBase64() };
+	};
+	const signPsbts = async ({ requests, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const signedPsbts = [];
+		for (const request$1 of requests) {
+			const signedPsbtResponse = await signPsbt({
+				request: request$1,
+				walletAccount
+			});
+			if (signedPsbtResponse) signedPsbts.push(signedPsbtResponse.signedPsbt);
+		}
+		return { signedPsbts };
+	};
+	return {
+		chain,
+		connect,
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: formatWalletProviderGroupKey(OYL_METADATA.displayName),
+		key,
+		metadata: OYL_METADATA,
+		signMessage: signMessage$1,
+		signPsbt,
+		signPsbts,
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/injected/utils/oyl/getOylBitcoinInjectedProvider/getOylBitcoinInjectedProvider.ts
+const OYL_BITCOIN_PROVIDER_LOCATOR = "oyl";
+const getOylBitcoinInjectedProvider = () => {
+	return getInjectedProviderFromWindow(OYL_BITCOIN_PROVIDER_LOCATOR);
+};
+
+//#endregion
+//#region src/injected/utils/phantom/createPhantomBitcoinWalletProvider/createPhantomBitcoinWalletProvider.ts
+const PHANTOM_METADATA = {
+	displayName: "Phantom",
+	icon: `${DYNAMIC_ICONIC_SPRITE_URL}#phantom`
+};
+const createPhantomBitcoinWalletProvider = ({ dynamicClient, injectedProvider }) => {
+	const chain = "BTC";
+	const walletProviderType = WalletProviderEnum.BrowserExtension;
+	const key = formatWalletProviderKey({
+		chain,
+		displayName: PHANTOM_METADATA.displayName,
+		walletProviderType
+	});
+	const connect = async () => {
+		const addresses = (await injectedProvider.requestAccounts()).map((account) => ({
+			address: account.address,
+			publicKey: account.publicKey,
+			type: account.purpose === "payment" ? "payment" : "ordinals"
+		}));
+		addresses.sort((a) => a.type === "ordinals" ? -1 : 1);
+		return { addresses };
+	};
+	const getActiveNetworkId = async () => getActiveNetworkIdFromLastKnownRegistry({
+		client: dynamicClient,
+		walletProviderKey: key
+	});
+	const getConnectedAddresses = async () => {
+		const { addresses } = await connect();
+		return { addresses: addresses.map((address$1) => address$1.address) };
+	};
+	const signMessage$1 = async ({ message, walletAccount, addressType }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		let addressToSignWith = walletAccount.address;
+		if (addressType) addressToSignWith = getWalletAccountAddressByType({
+			type: addressType,
+			walletAccount
+		}) ?? addressToSignWith;
+		const result = await injectedProvider.signMessage(addressToSignWith, new TextEncoder().encode(message));
+		return { signature: getBuffer().from(result.signature).toString("base64") };
+	};
+	const signPsbt = async ({ request: request$1, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const psbtFromBase64 = Psbt.fromBase64(request$1.unsignedPsbtBase64);
+		const inputsToSign = request$1.signature?.map((sig) => ({
+			address: sig.address,
+			sigHash: request$1.allowedSighash[0],
+			signingIndexes: sig.signingIndexes ?? []
+		})) ?? [];
+		const signedPsbt = await injectedProvider.signPSBT(psbtFromBase64.toBuffer(), { inputsToSign });
+		return { signedPsbt: Psbt.fromBuffer(signedPsbt).toBase64() };
+	};
+	const signPsbts = async ({ requests, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const signedPsbts = [];
+		for (const request$1 of requests) {
+			const signedPsbtResponse = await signPsbt({
+				request: request$1,
+				walletAccount
+			});
+			if (signedPsbtResponse) signedPsbts.push(signedPsbtResponse.signedPsbt);
+		}
+		return { signedPsbts };
+	};
+	const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
+		removeEventListeners: () => {
+			injectedProvider?.removeAllListeners();
+		},
+		setupEventListeners: ({ handleAccountsChanged }) => {
+			injectedProvider?.on("accountsChanged", (accounts) => {
+				handleAccountsChanged({ addresses: accounts.map((account) => account.address) });
+			});
+		},
+		supportedEvents: ["accountsChanged"]
+	});
+	const terminate = async () => {
+		cleanupEventEmitter();
+	};
+	return {
+		chain,
+		connect,
+		get events() {
+			return getEventEmitter();
+		},
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: formatWalletProviderGroupKey(PHANTOM_METADATA.displayName),
+		key,
+		metadata: PHANTOM_METADATA,
+		signMessage: signMessage$1,
+		signPsbt,
+		signPsbts,
+		terminate,
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/injected/utils/phantom/getPhantomInjectedProvider/getPhantomInjectedProvider.ts
+const PHANTOM_BITCOIN_PROVIDER_LOCATOR = "phantom.bitcoin";
+const getPhantomInjectedProvider = () => {
+	return getInjectedProviderFromWindow(PHANTOM_BITCOIN_PROVIDER_LOCATOR);
+};
+
+//#endregion
+//#region src/injected/utils/unisat/getUnisatInjectedProvider/getUnisatInjectedProvider.ts
+const UNISAT_PROVIDER_LOCATOR = "unisat_wallet";
+const getUnisatInjectedProvider = () => {
+	return getInjectedProviderFromWindow(UNISAT_PROVIDER_LOCATOR);
+};
+
+//#endregion
+//#region src/utils/signMultipleTransactionsWithSatsConnect/signMultipleTransactionsWithSatsConnect.ts
+const signMultipleTransactionsWithSatsConnect = async ({ network, psbts, provider }) => {
+	return { signedPsbts: (await new Promise((resolve, reject) => {
+		signMultipleTransactions({
+			getProvider: () => Promise.resolve(provider),
+			onCancel: () => {
+				reject(new UserRejectedError({ action: "sign psbts" }));
+			},
+			onFinish: (response) => {
+				resolve(response);
+			},
+			payload: {
+				message: "Sign Psbts",
+				network,
+				psbts
+			}
+		});
+	})).map((response) => response.psbtBase64) };
+};
+
+//#endregion
+//#region src/injected/utils/xverse/createXverseBitcoinWalletProvider/createXverseBitcoinWalletProvider.ts
+const XVERSE_METADATA = {
+	displayName: "Xverse",
+	icon: `${DYNAMIC_ICONIC_SPRITE_URL}#xverse`
+};
+const createXverseBitcoinWalletProvider = ({ dynamicClient, satsConnectProvider }) => {
+	const chain = "BTC";
+	const walletProviderType = WalletProviderEnum.BrowserExtension;
+	const key = formatWalletProviderKey({
+		chain,
+		displayName: XVERSE_METADATA.displayName,
+		walletProviderType
+	});
+	const requestPermissions = async () => {
+		const response = await request("wallet_requestPermissions", void 0);
+		if (response.status === "success") return;
+		throw response.error;
+	};
+	const connect = async () => {
+		await requestPermissions();
+		const response = await request("wallet_connect", null);
+		if (response.status !== "success") throw response.error;
+		const { addresses: connectedAddresses } = response.result;
+		const { addresses } = parseBitcoinConnectionResult({ connectedAddresses });
+		return { addresses };
+	};
+	const disconnect = async () => {
+		await request("wallet_renouncePermissions", null);
+	};
+	const getActiveNetworkId = async () => {
+		const response = await request("wallet_getNetwork", null);
+		let networkName = "mainnet";
+		if (response.status === "success") networkName = response.result.bitcoin.name.toLowerCase();
+		return getNetworkIdFromNetworkName({ networkName }, dynamicClient);
+	};
+	const getConnectedAddresses = async () => {
+		const response = await request("wallet_getAccount", null);
+		if (response.status === "success") return { addresses: response.result.addresses.map((address$1) => address$1.address) };
+		if (response.error.code !== RpcErrorCode.ACCESS_DENIED) throw response.error;
+		return { addresses: [] };
+	};
+	const sendBitcoin = async ({ transaction, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const response = await request("sendTransfer", { recipients: [{
+			address: transaction.recipientAddress,
+			amount: Number(transaction.amount)
+		}] });
+		if (response.status !== "success") throw response.error;
+		return { transactionId: response.result.txid };
+	};
+	const signMessage$1 = async ({ message, walletAccount, protocol, addressType }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		let addressToSignWith = walletAccount.address;
+		if (addressType) addressToSignWith = getWalletAccountAddressByType({
+			type: addressType,
+			walletAccount
+		}) ?? addressToSignWith;
+		const response = await request("signMessage", {
+			address: addressToSignWith,
+			message,
+			protocol: getSatsConnectSigningProtocol(protocol)
+		});
+		if (response.status !== "success") throw response.error;
+		return { signature: response.result.signature };
+	};
+	const signPsbt = async ({ request: request$1, walletAccount }) => {
+		if (!request$1.allowedSighash.length) throw new InvalidPsbtError("allowedSighash cannot be an empty array");
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const network = convertNetworkIdForPsbt((await getActiveNetworkId()).networkId);
+		const inputsToSign = getPsbtInputsToSignForSatsConnect({
+			psbt: Psbt.fromBase64(request$1.unsignedPsbtBase64, { network }),
+			request: request$1
+		});
+		const response = await request("signPsbt", {
+			broadcast: false,
+			psbt: request$1.unsignedPsbtBase64,
+			signInputs: inputsToSign.reduce((accum, curr) => {
+				if (!accum[curr.address]) accum[curr.address] = [];
+				accum[curr.address].push(...curr.signingIndexes);
+				return accum;
+			}, {})
+		});
+		if (response.status !== "success") throw response.error;
+		return { signedPsbt: response.result.psbt };
+	};
+	const signPsbts = async ({ requests, walletAccount }) => {
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const activeNetworkId = await getActiveNetworkId();
+		const network = convertNetworkIdForPsbt(activeNetworkId.networkId);
+		const networkType = convertNetworkIdToSatsConnectNetworkType(activeNetworkId.networkId);
+		const psbtsToSign = [];
+		for (const request$1 of requests) {
+			const inputsToSign = getPsbtInputsToSignForSatsConnect({
+				psbt: Psbt.fromBase64(request$1.unsignedPsbtBase64, { network }),
+				request: request$1
+			});
+			psbtsToSign.push({
+				inputsToSign,
+				psbtBase64: request$1.unsignedPsbtBase64
+			});
+		}
+		return { signedPsbts: (await signMultipleTransactionsWithSatsConnect({
+			network: { type: networkType },
+			provider: satsConnectProvider,
+			psbts: psbtsToSign
+		})).signedPsbts };
+	};
+	const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
+		removeEventListeners: ({ setupReturnValue }) => {
+			assertDefined(setupReturnValue, "Setup return value not defined");
+			setupReturnValue.removeAccountChangeListener();
+			setupReturnValue.accountDisconnectedListener();
+		},
+		setupEventListeners: ({ handleAccountsChanged, handleDisconnected }) => {
+			const removeAccountChangeListener = addListener("accountChange", ({ addresses }) => {
+				if (!addresses) return;
+				handleAccountsChanged({ addresses: addresses.map((address$1) => address$1.address) });
+			});
+			return {
+				accountDisconnectedListener: addListener("accountDisconnected", () => {
+					handleDisconnected();
+				}),
+				removeAccountChangeListener
+			};
+		},
+		supportedEvents: ["accountsChanged", "disconnected"]
+	});
+	const terminate = async () => {
+		cleanupEventEmitter();
+	};
+	return {
+		chain,
+		connect,
+		disconnect,
+		get events() {
+			return getEventEmitter();
+		},
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: formatWalletProviderGroupKey(XVERSE_METADATA.displayName),
+		key,
+		metadata: XVERSE_METADATA,
+		sendBitcoin,
+		signMessage: signMessage$1,
+		signPsbt,
+		signPsbts,
+		terminate,
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/injected/utils/xverse/getXverseInjectedProvider/getXverseInjectedProvider.ts
+const XVERSE_BITCOIN_PROVIDER_LOCATOR = "XverseProviders.BitcoinProvider";
+const getXverseInjectedProvider = () => {
+	return getInjectedProviderFromWindow(XVERSE_BITCOIN_PROVIDER_LOCATOR);
+};
+
+//#endregion
+//#region src/injected/addBitcoinInjectedWalletsExtension/addBitcoinInjectedWalletsExtension.ts
+const BITCOIN_INJECTED_WALLETS_EXTENSION_KEY = "bitcoinInjectedWallets";
+/**
+* Adds the Bitcoin Injected Wallets extension to the Dynamic client.
+*
+* This extension enables integration with many Bitcoin wallets, like MagicEden, Xverse, Unisat, Phantom, and more.
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+*/
+const addBitcoinInjectedWalletsExtension = (client = getDefaultClient()) => {
+	if (hasExtension({ extensionKey: BITCOIN_INJECTED_WALLETS_EXTENSION_KEY }, client)) return;
+	registerExtension({ extensionKey: BITCOIN_INJECTED_WALLETS_EXTENSION_KEY }, client);
+	registerBitcoinNetworkProviderBuilder(client);
+	const walletProviderRegistry = getWalletProviderRegistry(client);
+	const injectedWalletProviders = [];
+	const unisatInjectedProvider = getUnisatInjectedProvider();
+	if (unisatInjectedProvider) {
+		const unisatWalletProvider = createUnisatWalletProvider({
+			dynamicClient: client,
+			injectedProvider: unisatInjectedProvider
+		});
+		injectedWalletProviders.push(unisatWalletProvider);
+	}
+	const phantomInjectedProvider = getPhantomInjectedProvider();
+	if (phantomInjectedProvider) {
+		const phantomWalletProvider = createPhantomBitcoinWalletProvider({
+			dynamicClient: client,
+			injectedProvider: phantomInjectedProvider
+		});
+		injectedWalletProviders.push(phantomWalletProvider);
+	}
+	const xverseInjectedProvider = getXverseInjectedProvider();
+	if (xverseInjectedProvider) {
+		const xverseWalletProvider = createXverseBitcoinWalletProvider({
+			dynamicClient: client,
+			satsConnectProvider: xverseInjectedProvider
+		});
+		injectedWalletProviders.push(xverseWalletProvider);
+	}
+	const magicEdenInjectedProvider = getMagicEdenInjectedProvider();
+	if (magicEdenInjectedProvider) {
+		const magicEdenWalletProvider = createMagicEdenBitcoinWalletProvider({
+			dynamicClient: client,
+			satsConnectProvider: magicEdenInjectedProvider
+		});
+		injectedWalletProviders.push(magicEdenWalletProvider);
+	}
+	const okxInjectedProvider = getOkxBitcoinInjectedProvider();
+	if (okxInjectedProvider) {
+		const okxWalletProvider = createOkxBitcoinWalletProvider({
+			dynamicClient: client,
+			injectedProvider: okxInjectedProvider
+		});
+		injectedWalletProviders.push(okxWalletProvider);
+	}
+	const oneKeyInjectedProvider = getOneKeyBitcoinInjectedProvider();
+	if (oneKeyInjectedProvider) {
+		const oneKeyWalletProvider = createOneKeyBitcoinWalletProvider({
+			dynamicClient: client,
+			injectedProvider: oneKeyInjectedProvider
+		});
+		injectedWalletProviders.push(oneKeyWalletProvider);
+	}
+	const bitgetInjectedProvider = getBitgetBitcoinInjectedProvider();
+	if (bitgetInjectedProvider) {
+		const bitgetWalletProvider = createBitgetBitcoinWalletProvider({
+			dynamicClient: client,
+			injectedProvider: bitgetInjectedProvider
+		});
+		injectedWalletProviders.push(bitgetWalletProvider);
+	}
+	const binanceInjectedProvider = getBinanceBitcoinInjectedProvider();
+	if (binanceInjectedProvider) {
+		const binanceWalletProvider = createBinanceBitcoinWalletProvider({
+			dynamicClient: client,
+			injectedProvider: binanceInjectedProvider
+		});
+		injectedWalletProviders.push(binanceWalletProvider);
+	}
+	const oylInjectedProvider = getOylBitcoinInjectedProvider();
+	if (oylInjectedProvider) {
+		const oylWalletProvider = createOylBitcoinWalletProvider({
+			dynamicClient: client,
+			injectedProvider: oylInjectedProvider
+		});
+		injectedWalletProviders.push(oylWalletProvider);
+	}
+	const leatherInjectedProvider = getLeatherBitcoinInjectedProvider();
+	if (leatherInjectedProvider) {
+		const leatherWalletProvider = createLeatherBitcoinWalletProvider({
+			dynamicClient: client,
+			injectedProvider: leatherInjectedProvider
+		});
+		injectedWalletProviders.push(leatherWalletProvider);
+	}
+	injectedWalletProviders.forEach((walletProvider) => {
+		walletProviderRegistry.register({
+			priority: WalletProviderPriority.WINDOW_INJECT,
+			walletProvider
+		});
+	});
+};
+
+//#endregion
+export { version as a, name as i, InvalidPsbtError as n, getMempoolApiUrl as r, addBitcoinInjectedWalletsExtension as t };
+//# sourceMappingURL=addBitcoinInjectedWalletsExtension-DoOIj6RD.esm.js.map