@dynamic-labs-sdk/bitcoin 0.1.2 → 0.2.4

package/addBitcoinInjectedWalletsExtension.esm.js

@@ -1,1952 +0,0 @@
-import { createBaseNetworkProvider, getNetworkProviderBuilderRegistry, formatWalletProviderKey, createWalletProviderEventEmitter, DYNAMIC_ICONIC_SPRITE_URL, formatWalletProviderGroupKey, assertDefined, getInjectedProviderFromWindow, getActiveNetworkIdFromLastKnownRegistry, getBuffer, getDefaultClient, hasExtension, registerExtension, getWalletProviderRegistry, WalletProviderPriority } from '@dynamic-labs-sdk/client/core';
-import { BaseError, getNetworksData, assertWalletAccountSigningAvailability, UserRejectedError, getWalletAccountAddressByType } from '@dynamic-labs-sdk/client';
-import { WalletProviderEnum } from '@dynamic-labs/sdk-api-core';
-import { payments, Transaction, address, Psbt, networks } from 'bitcoinjs-lib';
-import { createUnsecuredToken } from 'jsontokens';
-import { BitcoinNetworkType, MessageSigningProtocols, addListener, signTransaction, signMessage, sendBtcTransaction, getAddress, AddressPurpose, signMultipleTransactions, request, RpcErrorCode } from 'sats-connect';
-
-var name = "@dynamic-labs-sdk/bitcoin";
-var version = "0.1.2";
-
-function _extends() {
-    _extends = Object.assign || function assign(target) {
-        for(var i = 1; i < arguments.length; i++){
-            var source = arguments[i];
-            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
-        }
-        return target;
-    };
-    return _extends.apply(this, arguments);
-}
-
-const MEMPOOL_API_URL = 'https://mempool.space/api';
-const MEMPOOL_API_URL_TESTNET = 'https://mempool.space/testnet/api';
-
-const getMempoolApiUrl = (address)=>address.startsWith('t') ? MEMPOOL_API_URL_TESTNET : MEMPOOL_API_URL;
-
-const satoshisToBtc = (satoshis)=>satoshis / 100000000;
-
-const fetchBtcBalance = async ({ address })=>{
-    const API_URL = getMempoolApiUrl(address);
-    const response = await fetch(`${API_URL}/address/${address}`);
-    if (!response.ok) {
-        return null;
-    }
-    const addressInfo = await response.json();
-    if (!(addressInfo == null ? void 0 : addressInfo.chain_stats) || !(addressInfo == null ? void 0 : addressInfo.mempool_stats)) {
-        return null;
-    }
-    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 = satoshisToBtc(confirmedBalanceInSats + unconfirmedBalanceInSats);
-    return balance.toString();
-};
-
-const createBitcoinNetworkProvider = (networkData)=>_extends({}, createBaseNetworkProvider('BTC', networkData), {
-        cluster: networkData.cluster,
-        getBalance: async ({ address })=>({
-                balance: await fetchBtcBalance({
-                    address
-                })
-            })
-    });
-
-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'
-    });
-};
-
-class InvalidPsbtError extends BaseError {
-    constructor(message){
-        super({
-            cause: null,
-            code: 'invalid_psbt_error',
-            docsUrl: null,
-            name: 'InvalidPsbtError',
-            shortMessage: message
-        });
-    }
-}
-
-/**
- * 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 _input_witnessUtxo;
-    if (input == null ? void 0 : input.sighashType) {
-        return input.sighashType;
-    }
-    let isTaprootAddress = false;
-    if ((_input_witnessUtxo = input.witnessUtxo) == null ? void 0 : _input_witnessUtxo.script) {
-        try {
-            payments.p2tr({
-                output: input.witnessUtxo.script
-            });
-            isTaprootAddress = true;
-        } catch (e) {
-        // do nothing - address is not taproot
-        }
-    }
-    return isTaprootAddress ? Transaction.SIGHASH_DEFAULT : Transaction.SIGHASH_ALL;
-};
-
-const validateSigHash = ({ allowedSigHashTypes, input })=>{
-    const sigHashType = getSigHashType({
-        input
-    });
-    // 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 ? void 0 : allowedSigHashTypes.length) && !allowedSigHashTypes.includes(sigHashType)) {
-        throw new InvalidPsbtError(`sigHashType ${sigHashType} not in allowed list`);
-    }
-};
-
-/**
- * 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 {
-        var _input_witnessUtxo;
-        if ((_input_witnessUtxo = input.witnessUtxo) == null ? void 0 : _input_witnessUtxo.script) {
-            extractedAddress = address.fromOutputScript(input.witnessUtxo.script);
-        }
-        if (input.nonWitnessUtxo) {
-            const nonWitnessTxn = Transaction.fromBuffer(input.nonWitnessUtxo);
-            const txOut = nonWitnessTxn.outs[psbt.txInputs[index].index];
-            extractedAddress = address.fromOutputScript(txOut.script);
-        }
-        return extractedAddress;
-    } catch (e) {
-        return extractedAddress;
-    }
-};
-
-const validateSigningAddress = ({ index, inputAtIndex, psbt, signingAddress })=>{
-    // 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({
-        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}`);
-    }
-};
-
-/**
- * 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 == null ? 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 ? void 0 : 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
-            });
-        }
-    }
-};
-
-/**
- * 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 })=>{
-    const psbtSignOptions = {
-        autoFinalized: false
-    };
-    if (!request.signature) {
-        return psbtSignOptions;
-    }
-    validatePsbt({
-        allowedSigHashTypes: request.allowedSighash,
-        psbt,
-        signatureData: request.signature
-    });
-    const toSignInputs = [];
-    for (const signature of request.signature){
-        var _signature_signingIndexes;
-        if ((_signature_signingIndexes = signature.signingIndexes) == null ? void 0 : _signature_signingIndexes.length) {
-            for (const index of signature.signingIndexes){
-                toSignInputs.push({
-                    address: signature.address,
-                    disableAddressValidation: signature.disableAddressValidation,
-                    index,
-                    sighashTypes: request.allowedSighash
-                });
-            }
-        }
-    }
-    psbtSignOptions.toSignInputs = toSignInputs;
-    return psbtSignOptions;
-};
-
-const getNetworkIdFromNetworkName = ({ networkName }, client)=>{
-    var _btcNetworkData_find;
-    const networksData = getNetworksData(client);
-    const btcNetworkData = networksData.filter((data)=>data.chain === 'BTC');
-    var _btcNetworkData_find_networkId;
-    // try to find the correct networkId based on the network name (cluster)
-    // if not found, default to mainnet ('1');
-    const networkId = (_btcNetworkData_find_networkId = (_btcNetworkData_find = btcNetworkData.find((data)=>data.cluster === networkName)) == null ? void 0 : _btcNetworkData_find.networkId) != null ? _btcNetworkData_find_networkId : '1';
-    return {
-        networkId
-    };
-};
-
-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 ()=>{
-        const accounts = await injectedProvider.requestAccounts();
-        const address = accounts[0];
-        const publicKey = await injectedProvider.getPublicKey();
-        return {
-            addresses: [
-                {
-                    address,
-                    publicKey
-                }
-            ]
-        };
-    };
-    const getActiveNetworkId = async ()=>{
-        const network = await injectedProvider.getNetwork();
-        return getNetworkIdFromNetworkName({
-            networkName: network
-        }, dynamicClient);
-    };
-    const getConnectedAddresses = async ()=>{
-        const accounts = await injectedProvider.getAccounts();
-        return {
-            addresses: accounts
-        };
-    };
-    const signMessage = async ({ message, walletAccount, protocol })=>{
-        assertDefined(walletAccount, 'Wallet account not found');
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const signedMessage = await injectedProvider.signMessage(message, protocol);
-        return {
-            signature: signedMessage
-        };
-    };
-    const signPsbt = async ({ request, walletAccount })=>{
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64);
-        const psbtOptions = createPsbtOptions({
-            psbt: psbtFromBase64,
-            request
-        });
-        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 of requests){
-            const signedPsbtResponse = await signPsbt({
-                request,
-                walletAccount
-            });
-            if (signedPsbtResponse) {
-                signedPsbts.push(signedPsbtResponse.signedPsbt);
-            }
-        }
-        return {
-            signedPsbts
-        };
-    };
-    const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
-        removeEventListeners: ()=>{
-            injectedProvider == null ? void 0 : injectedProvider.removeAllListeners();
-        },
-        setupEventListeners: ({ handleAccountsChanged, handleNetworkChanged })=>{
-            injectedProvider == null ? void 0 : injectedProvider.on('accountsChanged', (addresses)=>{
-                handleAccountsChanged({
-                    addresses
-                });
-            });
-            injectedProvider == null ? void 0 : 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,
-        signPsbt,
-        signPsbts,
-        terminate,
-        walletProviderType
-    };
-};
-
-const BINANCE_BITCOIN_PROVIDER_LOCATOR = 'binancew3w.bitcoin';
-const getBinanceBitcoinInjectedProvider = ()=>{
-    return getInjectedProviderFromWindow(BINANCE_BITCOIN_PROVIDER_LOCATOR);
-};
-
-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 ()=>{
-        const addresses = await injectedProvider.requestAccounts();
-        return {
-            addresses: addresses.map((address)=>({
-                    address
-                }))
-        };
-    };
-    const disconnect = async ()=>{
-        return injectedProvider.disconnect();
-    };
-    const getActiveNetworkId = async ()=>{
-        const chain = await injectedProvider.getChain();
-        let networkName = 'mainnet';
-        if (chain.enum === 'BITCOIN_TESTNET') {
-            networkName = 'testnet';
-        } else if (chain.enum === 'BITCOIN_SIGNET') {
-            networkName = 'signet';
-        }
-        return getNetworkIdFromNetworkName({
-            networkName
-        }, dynamicClient);
-    };
-    const getConnectedAddresses = async ()=>{
-        const accounts = await injectedProvider.getAccounts();
-        return {
-            addresses: accounts
-        };
-    };
-    const sendBitcoin = async ({ transaction, walletAccount })=>{
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const transactionId = await injectedProvider.sendBitcoin(transaction.recipientAddress, Number(transaction.amount));
-        return {
-            transactionId
-        };
-    };
-    const signMessage = async ({ message, walletAccount, protocol })=>{
-        assertDefined(walletAccount, 'Wallet account not found');
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const signedMessage = await injectedProvider.signMessage(message, protocol);
-        return {
-            signature: signedMessage
-        };
-    };
-    const signPsbt = async ({ request, walletAccount })=>{
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64);
-        const signedPsbtHex = await injectedProvider.signPsbt(psbtFromBase64.toHex(), createPsbtOptions({
-            psbt: psbtFromBase64,
-            request
-        }));
-        return {
-            signedPsbt: Psbt.fromHex(signedPsbtHex).toBase64()
-        };
-    };
-    const signPsbts = async ({ requests, walletAccount })=>{
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const psbtHexs = [];
-        const psbtOptions = [];
-        for (const request of requests){
-            const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64);
-            psbtHexs.push(psbtFromBase64.toHex());
-            psbtOptions.push(createPsbtOptions({
-                psbt: psbtFromBase64,
-                request
-            }));
-        }
-        const signedPsbtHexs = await injectedProvider.signPsbts(psbtHexs, psbtOptions);
-        return {
-            signedPsbts: signedPsbtHexs.map((signedPsbtHex)=>Psbt.fromHex(signedPsbtHex).toBase64())
-        };
-    };
-    const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
-        removeEventListeners: ()=>{
-            injectedProvider == null ? void 0 : injectedProvider.removeAllListeners();
-        },
-        setupEventListeners: ({ handleAccountsChanged, handleNetworkChanged })=>{
-            injectedProvider == null ? void 0 : injectedProvider.on('accountsChanged', (addresses)=>{
-                handleAccountsChanged({
-                    addresses
-                });
-            });
-            injectedProvider == null ? void 0 : 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,
-        signPsbt,
-        signPsbts,
-        terminate,
-        walletProviderType
-    };
-};
-
-const BITGET_METADATA = {
-    displayName: 'Bitget Wallet',
-    icon: `${DYNAMIC_ICONIC_SPRITE_URL}#bitgetwallet`
-};
-// The Bitget provider interface is the same as Unisat provider interface
-// https://docs.bitkeep.com/en/docs/guide/wallet/btc.html
-const createBitgetBitcoinWalletProvider = ({ dynamicClient, injectedProvider })=>{
-    const unisatWalletProvider = createUnisatWalletProvider({
-        dynamicClient,
-        injectedProvider
-    });
-    return _extends({}, unisatWalletProvider, {
-        groupKey: formatWalletProviderGroupKey(BITGET_METADATA.displayName),
-        key: formatWalletProviderKey({
-            chain: unisatWalletProvider.chain,
-            displayName: BITGET_METADATA.displayName,
-            walletProviderType: unisatWalletProvider.walletProviderType
-        }),
-        metadata: BITGET_METADATA
-    });
-};
-
-const BITGET_BITCOIN_PROVIDER_LOCATOR = 'bitkeep.unisat';
-// The Bitget provider interface is the same as Unisat provider interface
-// https://docs.bitkeep.com/en/docs/guide/wallet/btc.html
-const getBitgetBitcoinInjectedProvider = ()=>{
-    return getInjectedProviderFromWindow(BITGET_BITCOIN_PROVIDER_LOCATOR);
-};
-
-const convertNetworkIdForPsbt = (networkId)=>{
-    if (networkId === '1') {
-        return networks.bitcoin;
-    }
-    // use networks.testnet for both testnet and signet
-    if (networkId === '2' || networkId === '3') {
-        return networks.testnet;
-    }
-    return undefined;
-};
-
-const convertNetworkIdToLeatherNetworkName = (networkId)=>{
-    if (networkId === '1') {
-        return 'mainnet';
-    }
-    if (networkId === '2') {
-        return 'testnet';
-    }
-    if (networkId === '3') {
-        return 'signet';
-    }
-    return undefined;
-};
-
-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();
-        const networkName = convertNetworkIdToLeatherNetworkName(networkId);
-        return {
-            networkId,
-            networkName
-        };
-    };
-    const connect = async ()=>{
-        const response = await injectedProvider.request('getAddresses').catch(({ error })=>{
-            throw error;
-        });
-        const connectedAddresses = response.result.addresses;
-        const addresses = [];
-        const ordinalsAddress = connectedAddresses == null ? void 0 : connectedAddresses.find((address)=>address.type === 'p2tr');
-        if (ordinalsAddress) {
-            addresses.push({
-                address: ordinalsAddress.address,
-                publicKey: ordinalsAddress.publicKey,
-                type: 'ordinals'
-            });
-        }
-        const paymentAddress = connectedAddresses == null ? void 0 : connectedAddresses.find((address)=>address.type === 'p2wpkh');
-        if (paymentAddress) {
-            addresses.push({
-                address: paymentAddress.address,
-                publicKey: paymentAddress.publicKey,
-                type: 'payment'
-            });
-        }
-        return {
-            addresses
-        };
-    };
-    const getActiveNetworkId = async ()=>getActiveNetworkIdFromLastKnownRegistry({
-            client: dynamicClient,
-            walletProviderKey: key
-        });
-    // there's no specific method to get connected addresses in Leather
-    const getConnectedAddresses = async ()=>{
-        const accounts = await connect();
-        return {
-            addresses: accounts.addresses.map((address)=>address.address)
-        };
-    };
-    const sendBitcoin = async ({ transaction })=>{
-        const { networkName } = await getNetworkPayload();
-        const response = await injectedProvider.request('sendTransfer', {
-            account: 0,
-            address: transaction.recipientAddress,
-            amount: transaction.amount.toString(),
-            // network is required, so fallback to mainnet
-            network: networkName != null ? networkName : 'mainnet'
-        }).catch(({ error })=>{
-            throw error;
-        });
-        return {
-            transactionId: response.result.txid
-        };
-    };
-    const signMessage = async ({ message, walletAccount, addressType })=>{
-        assertDefined(walletAccount, 'Wallet account not found');
-        let paymentType = 'p2tr';
-        if (addressType === 'payment') {
-            paymentType = 'p2wpkh';
-        }
-        const { networkName } = await getNetworkPayload();
-        const response = await injectedProvider.request('signMessage', {
-            message,
-            network: networkName,
-            paymentType
-        }).catch(({ error })=>{
-            throw error;
-        });
-        return {
-            signature: response.result.signature
-        };
-    };
-    const signPsbt = async ({ request })=>{
-        var _request_signature;
-        const { networkId, networkName } = await getNetworkPayload();
-        const psbtNetwork = convertNetworkIdForPsbt(networkId);
-        const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64, {
-            network: psbtNetwork
-        });
-        const signAtIndex = (_request_signature = request.signature) == null ? void 0 : _request_signature.flatMap((sig)=>sig.signingIndexes).filter(Number.isInteger);
-        const response = await injectedProvider.request('signPsbt', {
-            account: 0,
-            allowedSighash: request.allowedSighash,
-            broadcast: false,
-            hex: psbtFromBase64.toHex(),
-            // network is required, so fallback to mainnet
-            network: networkName != null ? networkName : 'mainnet',
-            signAtIndex
-        }).catch(({ error })=>{
-            throw error;
-        });
-        const signedPsbtHex = response.result.hex;
-        return {
-            signedPsbt: Psbt.fromHex(signedPsbtHex, {
-                network: psbtNetwork
-            }).toBase64()
-        };
-    };
-    const signPsbts = async ({ requests, walletAccount })=>{
-        const signedPsbts = [];
-        for (const request of requests){
-            const signedPsbtResponse = await signPsbt({
-                request});
-            if (signedPsbtResponse) {
-                signedPsbts.push(signedPsbtResponse.signedPsbt);
-            }
-        }
-        return {
-            signedPsbts
-        };
-    };
-    return {
-        chain,
-        connect,
-        getActiveNetworkId,
-        getConnectedAddresses,
-        groupKey: formatWalletProviderGroupKey(LEATHER_METADATA.displayName),
-        key,
-        metadata: LEATHER_METADATA,
-        sendBitcoin,
-        signMessage,
-        signPsbt,
-        signPsbts,
-        walletProviderType
-    };
-};
-
-const LEATHER_BITCOIN_PROVIDER_LOCATOR = 'LeatherProvider';
-const getLeatherBitcoinInjectedProvider = ()=>{
-    return getInjectedProviderFromWindow(LEATHER_BITCOIN_PROVIDER_LOCATOR);
-};
-
-const convertNetworkIdToSatsConnectNetworkType = (networkId)=>{
-    if (networkId === '2') {
-        return BitcoinNetworkType.Testnet;
-    }
-    if (networkId === '3') {
-        return BitcoinNetworkType.Signet;
-    }
-    // fallback to mainnet
-    return BitcoinNetworkType.Mainnet;
-};
-
-/**
- * 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, isLegacySatsConnect })=>{
-    if (!request.signature) {
-        return [];
-    }
-    validatePsbt({
-        allowedSigHashTypes: request.allowedSighash,
-        psbt,
-        signatureData: request.signature
-    });
-    const inputsToSign = [];
-    for (const signature of request.signature){
-        var _signature_signingIndexes;
-        if ((_signature_signingIndexes = signature.signingIndexes) == null ? void 0 : _signature_signingIndexes.length) {
-            for (const index of signature.signingIndexes){
-                inputsToSign.push({
-                    address: signature.address,
-                    sigHash: isLegacySatsConnect ? getSigHashType({
-                        input: psbt.data.inputs[index]
-                    }) : request.allowedSighash[0],
-                    signingIndexes: [
-                        index
-                    ]
-                });
-            }
-        }
-    }
-    return inputsToSign;
-};
-
-const getSatsConnectSigningProtocol = (protocol)=>{
-    if (!protocol) {
-        return undefined;
-    }
-    return protocol === 'ecdsa' ? MessageSigningProtocols.ECDSA : MessageSigningProtocols.BIP322;
-};
-
-const parseBitcoinConnectionResult = ({ connectedAddresses })=>{
-    // Xverse will return other addresses/types that we don't support
-    // so we filter them out
-    const filteredAddresses = connectedAddresses.filter((address)=>address.purpose === 'ordinals' || address.purpose === 'payment');
-    const addresses = filteredAddresses.map((account)=>({
-            address: account.address,
-            publicKey: account.publicKey,
-            type: account.purpose === 'payment' ? 'payment' : 'ordinals'
-        }));
-    // put ordinals addresses first, as they should be the main walletAccount address
-    addresses.sort((a)=>a.type === 'ordinals' ? -1 : 1);
-    return {
-        addresses
-    };
-};
-
-const MAGIC_EDEN_METADATA = {
-    displayName: 'Magic Eden',
-    icon: `${DYNAMIC_ICONIC_SPRITE_URL}#magiceden`
-};
-// https://docs-wallet.magiceden.io/bitcoin/detecting-the-provider
-const createMagicEdenBitcoinWalletProvider = ({ dynamicClient, satsConnectProvider })=>{
-    const chain = 'BTC';
-    const walletProviderType = WalletProviderEnum.BrowserExtension;
-    const key = formatWalletProviderKey({
-        chain,
-        displayName: MAGIC_EDEN_METADATA.displayName,
-        walletProviderType
-    });
-    const getNetworkPayload = async ()=>{
-        const activeNetworkId = await getActiveNetworkId();
-        const networkType = convertNetworkIdToSatsConnectNetworkType(activeNetworkId.networkId);
-        return {
-            network: {
-                type: networkType
-            }
-        };
-    };
-    const connect = async ()=>{
-        const { network } = await getNetworkPayload();
-        return new Promise((resolve, reject)=>{
-            void 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
-        });
-    // there's no specific method to get connected addresses in Magic Eden
-    // so we use the connect method to get the addresses
-    const getConnectedAddresses = async ()=>{
-        const { addresses } = await connect();
-        return {
-            addresses: addresses.map((address)=>address.address)
-        };
-    };
-    const sendBitcoin = async ({ transaction, walletAccount })=>{
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        var _getWalletAccountAddressByType;
-        // should use payment address if available
-        const senderAddress = (_getWalletAccountAddressByType = getWalletAccountAddressByType({
-            type: 'payment',
-            walletAccount
-        })) != null ? _getWalletAccountAddressByType : walletAccount.address;
-        const { network } = await getNetworkPayload();
-        return new Promise((resolve, reject)=>{
-            void 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) {
-            var _getWalletAccountAddressByType;
-            addressToSignWith = (_getWalletAccountAddressByType = getWalletAccountAddressByType({
-                type: addressType,
-                walletAccount
-            })) != null ? _getWalletAccountAddressByType : addressToSignWith;
-        }
-        return new Promise((resolve, reject)=>{
-            void signMessage({
-                getProvider: async ()=>satsConnectProvider,
-                onCancel: ()=>{
-                    reject(new UserRejectedError({
-                        action: 'signMessage'
-                    }));
-                },
-                onFinish: async (response)=>{
-                    resolve({
-                        signature: response
-                    });
-                },
-                payload: {
-                    address: addressToSignWith,
-                    message: message,
-                    network,
-                    protocol: getSatsConnectSigningProtocol(protocol)
-                }
-            });
-        });
-    };
-    const signPsbt = async ({ request, walletAccount })=>{
-        if (!request.allowedSighash.length) {
-            throw new InvalidPsbtError('allowedSighash cannot be an empty array');
-        }
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const activeNetworkId = await getActiveNetworkId();
-        const network = convertNetworkIdForPsbt(activeNetworkId.networkId);
-        const { network: networkPayload } = await getNetworkPayload();
-        const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64, {
-            network
-        });
-        const inputsToSign = getPsbtInputsToSignForSatsConnect({
-            isLegacySatsConnect: true,
-            psbt: psbtFromBase64,
-            request
-        });
-        return new Promise((resolve, reject)=>{
-            void 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.unsignedPsbtBase64
-                }
-            });
-        });
-    };
-    const signPsbts = async ({ requests, walletAccount })=>{
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const activeNetworkId = await getActiveNetworkId();
-        const network = convertNetworkIdForPsbt(activeNetworkId.networkId);
-        const { network: networkPayload } = await getNetworkPayload();
-        const psbtsToSign = [];
-        for (const request of requests){
-            const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64, {
-                network
-            });
-            const inputsToSign = getPsbtInputsToSignForSatsConnect({
-                isLegacySatsConnect: true,
-                psbt: psbtFromBase64,
-                request
-            });
-            psbtsToSign.push({
-                inputsToSign,
-                psbtBase64: request.unsignedPsbtBase64
-            });
-        }
-        const signMultipleTransactionPayload = {
-            message: 'Sign Pbsts',
-            network: networkPayload,
-            psbts: psbtsToSign
-        };
-        // Magic Eden has implemented their own signTransactions feature, and have requested us
-        // to ensure we use it rather than the general Sats Connect API for this method
-        const request = createUnsecuredToken(signMultipleTransactionPayload);
-        const response = await satsConnectProvider.signMultipleTransactions(request);
-        return {
-            signedPsbts: response.map((response)=>response.psbtBase64)
-        };
-    };
-    const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
-        removeEventListeners: ({ setupReturnValue })=>{
-            assertDefined(setupReturnValue, 'Setup return value not defined');
-            setupReturnValue.removeAccountChangeListener();
-        },
-        setupEventListeners: ({ handleAccountsChanged })=>{
-            const removeAccountChangeListener = addListener('accountsChanged', (accounts)=>{
-                if (!accounts) {
-                    return;
-                }
-                handleAccountsChanged({
-                    addresses: accounts.map((account)=>account.address)
-                });
-            });
-            return {
-                removeAccountChangeListener
-            };
-        },
-        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
-    };
-};
-
-const MAGIC_EDEN_BITCOIN_PROVIDER_LOCATOR = 'magicEden.bitcoin';
-const getMagicEdenInjectedProvider = ()=>{
-    return getInjectedProviderFromWindow(MAGIC_EDEN_BITCOIN_PROVIDER_LOCATOR);
-};
-
-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, publicKey } = await injectedProvider.connect();
-        return {
-            addresses: [
-                {
-                    address,
-                    publicKey
-                }
-            ]
-        };
-    };
-    const getActiveNetworkId = async ()=>{
-        const network = await injectedProvider.getNetwork();
-        return getNetworkIdFromNetworkName({
-            networkName: network
-        }, dynamicClient);
-    };
-    const getConnectedAddresses = async ()=>{
-        const accounts = await injectedProvider.getAccounts();
-        return {
-            addresses: accounts
-        };
-    };
-    const sendBitcoin = async ({ transaction, walletAccount })=>{
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const transactionId = await injectedProvider.sendBitcoin(transaction.recipientAddress, transaction.amount.toString());
-        return {
-            transactionId
-        };
-    };
-    const signMessage = async ({ message, walletAccount, protocol })=>{
-        assertDefined(walletAccount, 'Wallet account not found');
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const signedMessage = await injectedProvider.signMessage(message, protocol);
-        return {
-            signature: signedMessage
-        };
-    };
-    const signPsbt = async ({ request, walletAccount })=>{
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64);
-        const signedPsbtHex = await injectedProvider.signPsbt(psbtFromBase64.toHex(), createPsbtOptions({
-            psbt: psbtFromBase64,
-            request
-        }));
-        return {
-            signedPsbt: Psbt.fromHex(signedPsbtHex).toBase64()
-        };
-    };
-    const signPsbts = async ({ requests, walletAccount })=>{
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const psbtHexs = [];
-        const psbtOptions = [];
-        for (const request of requests){
-            const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64);
-            psbtHexs.push(psbtFromBase64.toHex());
-            psbtOptions.push(createPsbtOptions({
-                psbt: psbtFromBase64,
-                request
-            }));
-        }
-        const signedPsbtHexs = await injectedProvider.signPsbts(psbtHexs, psbtOptions);
-        return {
-            signedPsbts: signedPsbtHexs.map((signedPsbtHex)=>Psbt.fromHex(signedPsbtHex).toBase64())
-        };
-    };
-    const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
-        removeEventListeners: ()=>{
-            injectedProvider == null ? void 0 : injectedProvider.removeAllListeners();
-        },
-        setupEventListeners: ({ handleAccountsChanged })=>{
-            injectedProvider == null ? void 0 : 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,
-        signPsbt,
-        signPsbts,
-        terminate,
-        walletProviderType
-    };
-};
-
-const OKX_BITCOIN_PROVIDER_LOCATOR = 'okxwallet.bitcoin';
-const getOkxBitcoinInjectedProvider = ()=>{
-    return getInjectedProviderFromWindow(OKX_BITCOIN_PROVIDER_LOCATOR);
-};
-
-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 ()=>{
-        const accounts = await injectedProvider.requestAccounts();
-        const address = accounts[0];
-        const publicKey = await injectedProvider.getPublicKey();
-        return {
-            addresses: [
-                {
-                    address,
-                    publicKey
-                }
-            ]
-        };
-    };
-    const getActiveNetworkId = async ()=>{
-        const network = await injectedProvider.getNetwork();
-        return getNetworkIdFromNetworkName({
-            networkName: network
-        }, dynamicClient);
-    };
-    const getConnectedAddresses = async ()=>{
-        const accounts = await injectedProvider.getAccounts();
-        return {
-            addresses: accounts
-        };
-    };
-    const sendBitcoin = async ({ transaction, walletAccount })=>{
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const transactionId = await injectedProvider.sendBitcoin(transaction.recipientAddress, transaction.amount.toString());
-        return {
-            transactionId
-        };
-    };
-    const signMessage = async ({ message, walletAccount, protocol })=>{
-        assertDefined(walletAccount, 'Wallet account not found');
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const signedMessage = await injectedProvider.signMessage(message, protocol);
-        return {
-            signature: signedMessage
-        };
-    };
-    const signPsbt = async ({ request, walletAccount })=>{
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const psbtFromBase64 = Psbt.fromBase64(request.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 of requests){
-            const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64);
-            psbtHexs.push(psbtFromBase64.toHex());
-        }
-        const signedPsbtHexs = await injectedProvider.signPsbts(psbtHexs, {
-            autoFinalized: false
-        });
-        return {
-            signedPsbts: signedPsbtHexs.map((signedPsbtHex)=>Psbt.fromHex(signedPsbtHex).toBase64())
-        };
-    };
-    const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
-        removeEventListeners: ()=>{
-            injectedProvider == null ? void 0 : injectedProvider.removeAllListeners();
-        },
-        setupEventListeners: ({ handleAccountsChanged, handleNetworkChanged })=>{
-            injectedProvider == null ? void 0 : injectedProvider.on('accountsChanged', (addresses)=>{
-                handleAccountsChanged({
-                    addresses
-                });
-            });
-            injectedProvider == null ? void 0 : 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,
-        signPsbt,
-        signPsbts,
-        terminate,
-        walletProviderType
-    };
-};
-
-const ONEKEY_BITCOIN_PROVIDER_LOCATOR = '$onekey.btc';
-const getOneKeyBitcoinInjectedProvider = ()=>{
-    return getInjectedProviderFromWindow(ONEKEY_BITCOIN_PROVIDER_LOCATOR);
-};
-
-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 ()=>{
-        const network = await injectedProvider.getNetwork();
-        return getNetworkIdFromNetworkName({
-            networkName: network
-        }, dynamicClient);
-    };
-    // there's no specific method to get connected addresses in Oyl
-    // so we check if the selected account is connected and return the addresses
-    // if not, we return an empty array
-    const getConnectedAddresses = async ()=>{
-        const isSelectedAccountConnected = await injectedProvider.isConnected();
-        if (!isSelectedAccountConnected) {
-            return {
-                addresses: []
-            };
-        }
-        // calling connect won't prompt the user to connect again if isConnected is true
-        const { addresses } = await connect();
-        return {
-            addresses: addresses.map((address)=>address.address)
-        };
-    };
-    const signMessage = async ({ message, walletAccount, addressType, protocol })=>{
-        assertDefined(walletAccount, 'Wallet account not found');
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        let addressToSignWith = walletAccount.address;
-        if (addressType) {
-            var _getWalletAccountAddressByType;
-            addressToSignWith = (_getWalletAccountAddressByType = getWalletAccountAddressByType({
-                type: addressType,
-                walletAccount
-            })) != null ? _getWalletAccountAddressByType : addressToSignWith;
-        }
-        const result = await injectedProvider.signMessage({
-            address: addressToSignWith,
-            message,
-            // Oyl Wallet calls it just bip322 instead of bip322-simple
-            protocol: protocol === 'bip322-simple' ? 'bip322' : protocol
-        });
-        return {
-            signature: result.signature
-        };
-    };
-    const signPsbt = async ({ request, walletAccount })=>{
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const psbtFromBase64 = Psbt.fromBase64(request.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 of requests){
-            const signedPsbtResponse = await signPsbt({
-                request,
-                walletAccount
-            });
-            if (signedPsbtResponse) {
-                signedPsbts.push(signedPsbtResponse.signedPsbt);
-            }
-        }
-        return {
-            signedPsbts
-        };
-    };
-    return {
-        chain,
-        connect,
-        getActiveNetworkId,
-        getConnectedAddresses,
-        groupKey: formatWalletProviderGroupKey(OYL_METADATA.displayName),
-        key,
-        metadata: OYL_METADATA,
-        signMessage,
-        signPsbt,
-        signPsbts,
-        walletProviderType
-    };
-};
-
-const OYL_BITCOIN_PROVIDER_LOCATOR = 'oyl';
-const getOylBitcoinInjectedProvider = ()=>{
-    return getInjectedProviderFromWindow(OYL_BITCOIN_PROVIDER_LOCATOR);
-};
-
-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 accounts = await injectedProvider.requestAccounts();
-        const addresses = accounts.map((account)=>({
-                address: account.address,
-                publicKey: account.publicKey,
-                type: account.purpose === 'payment' ? 'payment' : 'ordinals'
-            }));
-        // put ordinals addresses first, as they should be the main walletAccount address
-        addresses.sort((a)=>a.type === 'ordinals' ? -1 : 1);
-        return {
-            addresses
-        };
-    };
-    const getActiveNetworkId = async ()=>getActiveNetworkIdFromLastKnownRegistry({
-            client: dynamicClient,
-            walletProviderKey: key
-        });
-    // there's no specific method to get connected addresses in Phantom
-    // so we use the connect method to get the addresses
-    const getConnectedAddresses = async ()=>{
-        const { addresses } = await connect();
-        return {
-            addresses: addresses.map((address)=>address.address)
-        };
-    };
-    const signMessage = async ({ message, walletAccount, addressType })=>{
-        assertDefined(walletAccount, 'Wallet account not found');
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        let addressToSignWith = walletAccount.address;
-        if (addressType) {
-            var _getWalletAccountAddressByType;
-            addressToSignWith = (_getWalletAccountAddressByType = getWalletAccountAddressByType({
-                type: addressType,
-                walletAccount
-            })) != null ? _getWalletAccountAddressByType : addressToSignWith;
-        }
-        const result = await injectedProvider.signMessage(addressToSignWith, new TextEncoder().encode(message));
-        return {
-            signature: getBuffer().from(result.signature).toString('base64')
-        };
-    };
-    const signPsbt = async ({ request, walletAccount })=>{
-        var _request_signature;
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64);
-        var _request_signature_map;
-        const inputsToSign = (_request_signature_map = (_request_signature = request.signature) == null ? void 0 : _request_signature.map((sig)=>{
-            var _sig_signingIndexes;
-            return {
-                address: sig.address,
-                sigHash: request.allowedSighash[0],
-                signingIndexes: (_sig_signingIndexes = sig.signingIndexes) != null ? _sig_signingIndexes : []
-            };
-        })) != null ? _request_signature_map : [];
-        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 of requests){
-            const signedPsbtResponse = await signPsbt({
-                request,
-                walletAccount
-            });
-            if (signedPsbtResponse) {
-                signedPsbts.push(signedPsbtResponse.signedPsbt);
-            }
-        }
-        return {
-            signedPsbts
-        };
-    };
-    const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
-        removeEventListeners: ()=>{
-            injectedProvider == null ? void 0 : injectedProvider.removeAllListeners();
-        },
-        setupEventListeners: ({ handleAccountsChanged })=>{
-            injectedProvider == null ? void 0 : 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,
-        signPsbt,
-        signPsbts,
-        terminate,
-        walletProviderType
-    };
-};
-
-const PHANTOM_BITCOIN_PROVIDER_LOCATOR = 'phantom.bitcoin';
-const getPhantomInjectedProvider = ()=>{
-    return getInjectedProviderFromWindow(PHANTOM_BITCOIN_PROVIDER_LOCATOR);
-};
-
-// using `unisat_wallet` instead of `unisat` to avoid conflicts with other wallets
-// injecting themselves into the window.unisat object, like OneKey wallet.
-const UNISAT_PROVIDER_LOCATOR = 'unisat_wallet';
-const getUnisatInjectedProvider = ()=>{
-    return getInjectedProviderFromWindow(UNISAT_PROVIDER_LOCATOR);
-};
-
-const signMultipleTransactionsWithSatsConnect = async ({ network, psbts, provider })=>{
-    const response = await new Promise((resolve, reject)=>{
-        void signMultipleTransactions({
-            getProvider: ()=>Promise.resolve(provider),
-            onCancel: ()=>{
-                reject(new UserRejectedError({
-                    action: 'sign psbts'
-                }));
-            },
-            onFinish: (response)=>{
-                resolve(response);
-            },
-            payload: {
-                message: 'Sign Psbts',
-                network,
-                psbts
-            }
-        });
-    });
-    return {
-        signedPsbts: response.map((response)=>response.psbtBase64)
-    };
-};
-
-const XVERSE_METADATA = {
-    displayName: 'Xverse',
-    icon: `${DYNAMIC_ICONIC_SPRITE_URL}#xverse`
-};
-// https://docs.xverse.app/sats-connect/wallet-methods/request-methods
-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', undefined);
-        if (response.status === 'success') {
-            return;
-        }
-        throw response.error;
-    };
-    const connect = async ()=>{
-        // requesting permissions on initial connect will avoid
-        // connection prompt for other requests
-        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)=>address.address)
-            };
-        }
-        if (response.error.code !== RpcErrorCode.ACCESS_DENIED) {
-            throw response.error;
-        }
-        // if error is access denied, it means that the selected account is not
-        // connected to the app, so return empty array
-        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 = async ({ message, walletAccount, protocol, addressType })=>{
-        assertDefined(walletAccount, 'Wallet account not found');
-        await assertWalletAccountSigningAvailability({
-            walletAccount
-        }, dynamicClient);
-        let addressToSignWith = walletAccount.address;
-        if (addressType) {
-            var _getWalletAccountAddressByType;
-            addressToSignWith = (_getWalletAccountAddressByType = getWalletAccountAddressByType({
-                type: addressType,
-                walletAccount
-            })) != null ? _getWalletAccountAddressByType : 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 activeNetworkId = await getActiveNetworkId();
-        const network = convertNetworkIdForPsbt(activeNetworkId.networkId);
-        const psbtFromBase64 = Psbt.fromBase64(request$1.unsignedPsbtBase64, {
-            network
-        });
-        const inputsToSign = getPsbtInputsToSignForSatsConnect({
-            psbt: psbtFromBase64,
-            request: request$1
-        });
-        const signPbstPayload = {
-            broadcast: false,
-            psbt: request$1.unsignedPsbtBase64,
-            // we have to combine signing indexes for like addresses
-            signInputs: inputsToSign.reduce((accum, curr)=>{
-                if (!accum[curr.address]) {
-                    accum[curr.address] = [];
-                }
-                accum[curr.address].push(...curr.signingIndexes);
-                return accum;
-            }, {})
-        };
-        const response = await request('signPsbt', signPbstPayload);
-        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 of requests){
-            const psbtFromBase64 = Psbt.fromBase64(request.unsignedPsbtBase64, {
-                network
-            });
-            const inputsToSign = getPsbtInputsToSignForSatsConnect({
-                psbt: psbtFromBase64,
-                request
-            });
-            psbtsToSign.push({
-                inputsToSign,
-                psbtBase64: request.unsignedPsbtBase64
-            });
-        }
-        const response = await signMultipleTransactionsWithSatsConnect({
-            network: {
-                type: networkType
-            },
-            provider: satsConnectProvider,
-            psbts: psbtsToSign
-        });
-        return {
-            signedPsbts: response.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)=>address.address)
-                });
-            });
-            const accountDisconnectedListener = addListener('accountDisconnected', ()=>{
-                handleDisconnected();
-            });
-            return {
-                accountDisconnectedListener,
-                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,
-        signPsbt,
-        signPsbts,
-        terminate,
-        walletProviderType
-    };
-};
-
-const XVERSE_BITCOIN_PROVIDER_LOCATOR = 'XverseProviders.BitcoinProvider';
-const getXverseInjectedProvider = ()=>{
-    return getInjectedProviderFromWindow(XVERSE_BITCOIN_PROVIDER_LOCATOR);
-};
-
-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 = [];
-    // Create and register Unisat wallet provider
-    const unisatInjectedProvider = getUnisatInjectedProvider();
-    if (unisatInjectedProvider) {
-        const unisatWalletProvider = createUnisatWalletProvider({
-            dynamicClient: client,
-            injectedProvider: unisatInjectedProvider
-        });
-        injectedWalletProviders.push(unisatWalletProvider);
-    }
-    // Create and register Phantom wallet provider
-    const phantomInjectedProvider = getPhantomInjectedProvider();
-    if (phantomInjectedProvider) {
-        const phantomWalletProvider = createPhantomBitcoinWalletProvider({
-            dynamicClient: client,
-            injectedProvider: phantomInjectedProvider
-        });
-        injectedWalletProviders.push(phantomWalletProvider);
-    }
-    // Create and register Xverse wallet provider
-    const xverseInjectedProvider = getXverseInjectedProvider();
-    if (xverseInjectedProvider) {
-        const xverseWalletProvider = createXverseBitcoinWalletProvider({
-            dynamicClient: client,
-            satsConnectProvider: xverseInjectedProvider
-        });
-        injectedWalletProviders.push(xverseWalletProvider);
-    }
-    // Create and register MagicEden wallet provider
-    const magicEdenInjectedProvider = getMagicEdenInjectedProvider();
-    if (magicEdenInjectedProvider) {
-        const magicEdenWalletProvider = createMagicEdenBitcoinWalletProvider({
-            dynamicClient: client,
-            satsConnectProvider: magicEdenInjectedProvider
-        });
-        injectedWalletProviders.push(magicEdenWalletProvider);
-    }
-    // Create and register OKX wallet provider
-    const okxInjectedProvider = getOkxBitcoinInjectedProvider();
-    if (okxInjectedProvider) {
-        const okxWalletProvider = createOkxBitcoinWalletProvider({
-            dynamicClient: client,
-            injectedProvider: okxInjectedProvider
-        });
-        injectedWalletProviders.push(okxWalletProvider);
-    }
-    // Create and register OneKey wallet provider
-    const oneKeyInjectedProvider = getOneKeyBitcoinInjectedProvider();
-    if (oneKeyInjectedProvider) {
-        const oneKeyWalletProvider = createOneKeyBitcoinWalletProvider({
-            dynamicClient: client,
-            injectedProvider: oneKeyInjectedProvider
-        });
-        injectedWalletProviders.push(oneKeyWalletProvider);
-    }
-    // Create and register Bitget wallet provider
-    const bitgetInjectedProvider = getBitgetBitcoinInjectedProvider();
-    if (bitgetInjectedProvider) {
-        const bitgetWalletProvider = createBitgetBitcoinWalletProvider({
-            dynamicClient: client,
-            injectedProvider: bitgetInjectedProvider
-        });
-        injectedWalletProviders.push(bitgetWalletProvider);
-    }
-    // Create and register Binance wallet provider
-    const binanceInjectedProvider = getBinanceBitcoinInjectedProvider();
-    if (binanceInjectedProvider) {
-        const binanceWalletProvider = createBinanceBitcoinWalletProvider({
-            dynamicClient: client,
-            injectedProvider: binanceInjectedProvider
-        });
-        injectedWalletProviders.push(binanceWalletProvider);
-    }
-    // Create and register OYL wallet provider
-    const oylInjectedProvider = getOylBitcoinInjectedProvider();
-    if (oylInjectedProvider) {
-        const oylWalletProvider = createOylBitcoinWalletProvider({
-            dynamicClient: client,
-            injectedProvider: oylInjectedProvider
-        });
-        injectedWalletProviders.push(oylWalletProvider);
-    }
-    // Create and register Leather wallet provider
-    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
-        });
-    });
-};
-
-export { InvalidPsbtError as I, addBitcoinInjectedWalletsExtension as a, getMempoolApiUrl as g, name as n, version as v };