@dynamic-labs-sdk/bitcoin 0.1.0-alpha.21 → 0.1.0-alpha.22

package/addBitcoinInjectedWalletsExtension.cjs.js

@@ -4,10 +4,11 @@ var core = require('@dynamic-labs-sdk/client/core');
 var client = require('@dynamic-labs-sdk/client');
 var sdkApiCore = require('@dynamic-labs/sdk-api-core');
 var bitcoinjsLib = require('bitcoinjs-lib');
+var jsontokens = require('jsontokens');
 var satsConnect = require('sats-connect');
 
 var name = "@dynamic-labs-sdk/bitcoin";
-var version = "0.1.0-alpha.21";
+var version = "0.1.0-alpha.22";
 
 function _extends() {
     _extends = Object.assign || function assign(target) {
@@ -64,6 +65,468 @@ const registerBitcoinNetworkProviderBuilder = (client)=>{
     });
 };
 
+class InvalidPsbtError extends client.BaseError {
+    constructor(message){
+        super({
+            cause: null,
+            code: 'invalid_psbt_error',
+            docsUrl: null,
+            name: 'InvalidPsbtError',
+            shortMessage: message
+        });
+    }
+}
+
+const convertNetworkIdForPsbt = (networkId)=>{
+    if (networkId === '1') {
+        return bitcoinjsLib.networks.bitcoin;
+    }
+    if (networkId === '2') {
+        return bitcoinjsLib.networks.testnet;
+    }
+    return undefined;
+};
+
+const convertNetworkIdToSatsConnectNetworkType = (networkId)=>{
+    if (networkId === '2') {
+        return satsConnect.BitcoinNetworkType.Testnet;
+    }
+    // fallback to mainnet
+    return satsConnect.BitcoinNetworkType.Mainnet;
+};
+
+/**
+ * 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 {
+            bitcoinjsLib.payments.p2tr({
+                output: input.witnessUtxo.script
+            });
+            isTaprootAddress = true;
+        } catch (e) {
+        // do nothing - address is not taproot
+        }
+    }
+    return isTaprootAddress ? bitcoinjsLib.Transaction.SIGHASH_DEFAULT : bitcoinjsLib.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 = bitcoinjsLib.address.fromOutputScript(input.witnessUtxo.script);
+        }
+        if (input.nonWitnessUtxo) {
+            const nonWitnessTxn = bitcoinjsLib.Transaction.fromBuffer(input.nonWitnessUtxo);
+            const txOut = nonWitnessTxn.outs[psbt.txInputs[index].index];
+            extractedAddress = bitcoinjsLib.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 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' ? satsConnect.MessageSigningProtocols.ECDSA : satsConnect.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: `${core.DYNAMIC_ICONIC_SPRITE_URL}#magiceden`
+};
+// https://docs-wallet.magiceden.io/bitcoin/detecting-the-provider
+const createMagicEdenBitcoinWalletProvider = ({ dynamicClient, satsConnectProvider })=>{
+    const chain = 'BTC';
+    const walletProviderType = sdkApiCore.WalletProviderEnum.BrowserExtension;
+    const key = core.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 satsConnect.getAddress({
+                getProvider: async ()=>satsConnectProvider,
+                onCancel: ()=>{
+                    reject(new client.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: [
+                        satsConnect.AddressPurpose.Ordinals,
+                        satsConnect.AddressPurpose.Payment
+                    ]
+                }
+            });
+        });
+    };
+    const getActiveNetworkId = async ()=>core.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 client.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        var _getWalletAccountAddressByType;
+        // should use payment address if available
+        const senderAddress = (_getWalletAccountAddressByType = client.getWalletAccountAddressByType({
+            type: 'payment',
+            walletAccount
+        })) != null ? _getWalletAccountAddressByType : walletAccount.address;
+        const { network } = await getNetworkPayload();
+        return new Promise((resolve, reject)=>{
+            void satsConnect.sendBtcTransaction({
+                getProvider: async ()=>satsConnectProvider,
+                onCancel: ()=>{
+                    reject(new client.UserRejectedError({
+                        action: 'sendBitcoin'
+                    }));
+                },
+                onFinish: (response)=>{
+                    resolve({
+                        transactionId: response
+                    });
+                },
+                payload: {
+                    network,
+                    recipients: [
+                        {
+                            address: transaction.recipientAddress,
+                            amountSats: BigInt(transaction.amount)
+                        }
+                    ],
+                    senderAddress
+                }
+            });
+        });
+    };
+    const signMessage = async ({ message, walletAccount, protocol, addressType })=>{
+        core.assertDefined(walletAccount, 'Wallet account not found');
+        await client.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const { network } = await getNetworkPayload();
+        let addressToSignWith = walletAccount.address;
+        if (addressType) {
+            var _getWalletAccountAddressByType;
+            addressToSignWith = (_getWalletAccountAddressByType = client.getWalletAccountAddressByType({
+                type: addressType,
+                walletAccount
+            })) != null ? _getWalletAccountAddressByType : addressToSignWith;
+        }
+        return new Promise((resolve, reject)=>{
+            void satsConnect.signMessage({
+                getProvider: async ()=>satsConnectProvider,
+                onCancel: ()=>{
+                    reject(new client.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 client.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const activeNetworkId = await getActiveNetworkId();
+        const network = convertNetworkIdForPsbt(activeNetworkId.networkId);
+        const { network: networkPayload } = await getNetworkPayload();
+        const psbtFromBase64 = bitcoinjsLib.Psbt.fromBase64(request.unsignedPsbtBase64, {
+            network
+        });
+        const inputsToSign = getPsbtInputsToSignForSatsConnect({
+            isLegacySatsConnect: true,
+            psbt: psbtFromBase64,
+            request
+        });
+        return new Promise((resolve, reject)=>{
+            void satsConnect.signTransaction({
+                getProvider: async ()=>satsConnectProvider,
+                onCancel: ()=>{
+                    reject(new client.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 client.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 = bitcoinjsLib.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 = jsontokens.createUnsecuredToken(signMultipleTransactionPayload);
+        const response = await satsConnectProvider.signMultipleTransactions(request);
+        return {
+            signedPsbts: response.map((response)=>response.psbtBase64)
+        };
+    };
+    const { getEventEmitter, cleanupEventEmitter } = core.createWalletProviderEventEmitter({
+        removeEventListeners: ({ setupReturnValue })=>{
+            core.assertDefined(setupReturnValue, 'Setup return value not defined');
+            setupReturnValue.removeAccountChangeListener();
+        },
+        setupEventListeners: ({ handleAccountsChanged })=>{
+            const removeAccountChangeListener = satsConnect.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: core.formatWalletProviderGroupKey(MAGIC_EDEN_METADATA.displayName),
+        key,
+        metadata: MAGIC_EDEN_METADATA,
+        sendBitcoin,
+        signMessage,
+        signPsbt,
+        signPsbts,
+        terminate,
+        walletProviderType
+    };
+};
+
+const MAGIC_EDEN_BITCOIN_PROVIDER_LOCATOR = 'magicEden.bitcoin';
+const getMagicEdenInjectedProvider = ()=>{
+    return core.getInjectedProviderFromWindow(MAGIC_EDEN_BITCOIN_PROVIDER_LOCATOR);
+};
+
 const PHANTOM_METADATA = {
     displayName: 'Phantom',
     icon: `${core.DYNAMIC_ICONIC_SPRITE_URL}#phantom`
@@ -169,7 +632,10 @@ const createPhantomBitcoinWalletProvider = ({ dynamicClient, injectedProvider })
                     addresses: accounts.map((account)=>account.address)
                 });
             });
-        }
+        },
+        supportedEvents: [
+            'accountsChanged'
+        ]
     });
     const terminate = async ()=>{
         cleanupEventEmitter();
@@ -198,131 +664,6 @@ const getPhantomInjectedProvider = ()=>{
     return core.getInjectedProviderFromWindow(PHANTOM_BITCOIN_PROVIDER_LOCATOR);
 };
 
-class InvalidPsbtError extends client.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 {
-            bitcoinjsLib.payments.p2tr({
-                output: input.witnessUtxo.script
-            });
-            isTaprootAddress = true;
-        } catch (e) {
-        // do nothing - address is not taproot
-        }
-    }
-    return isTaprootAddress ? bitcoinjsLib.Transaction.SIGHASH_DEFAULT : bitcoinjsLib.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 = bitcoinjsLib.address.fromOutputScript(input.witnessUtxo.script);
-        }
-        if (input.nonWitnessUtxo) {
-            const nonWitnessTxn = bitcoinjsLib.Transaction.fromBuffer(input.nonWitnessUtxo);
-            const txOut = nonWitnessTxn.outs[psbt.txInputs[index].index];
-            extractedAddress = bitcoinjsLib.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
@@ -456,7 +797,11 @@ const createUnisatWalletProvider = ({ dynamicClient, injectedProvider })=>{
                     networkId: network
                 });
             });
-        }
+        },
+        supportedEvents: [
+            'accountsChanged',
+            'networkChanged'
+        ]
     });
     const terminate = async ()=>{
         cleanupEventEmitter();
@@ -487,64 +832,6 @@ const getUnisatInjectedProvider = ()=>{
     return core.getInjectedProviderFromWindow(UNISAT_PROVIDER_LOCATOR);
 };
 
-const convertNetworkIdForPsbt = (networkId)=>{
-    if (networkId === '1') {
-        return bitcoinjsLib.networks.bitcoin;
-    }
-    if (networkId === '2') {
-        return bitcoinjsLib.networks.testnet;
-    }
-    return undefined;
-};
-
-const convertNetworkIdToSatsConnectNetworkType = (networkId)=>{
-    if (networkId === '2') {
-        return satsConnect.BitcoinNetworkType.Testnet;
-    }
-    // fallback to mainnet
-    return satsConnect.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' ? satsConnect.MessageSigningProtocols.ECDSA : satsConnect.MessageSigningProtocols.BIP322;
-};
-
 const signMultipleTransactionsWithSatsConnect = async ({ network, psbts, provider })=>{
     const response = await new Promise((resolve, reject)=>{
         void satsConnect.signMultipleTransactions({
@@ -598,16 +885,9 @@ const createXverseBitcoinWalletProvider = ({ dynamicClient, satsConnectProvider
             throw response.error;
         }
         const { addresses: connectedAddresses } = response.result;
-        // 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);
+        const { addresses } = parseBitcoinConnectionResult({
+            connectedAddresses
+        });
         return {
             addresses
         };
@@ -769,7 +1049,11 @@ const createXverseBitcoinWalletProvider = ({ dynamicClient, satsConnectProvider
                 accountDisconnectedListener,
                 removeAccountChangeListener
             };
-        }
+        },
+        supportedEvents: [
+            'accountsChanged',
+            'disconnected'
+        ]
     });
     const terminate = async ()=>{
         cleanupEventEmitter();
@@ -846,7 +1130,15 @@ const BITCOIN_INJECTED_WALLETS_EXTENSION_KEY = 'bitcoinInjectedWallets';
         });
         injectedWalletProviders.push(xverseWalletProvider);
     }
-    // TODO: create and register MagicEden wallet provider
+    // Create and register MagicEden wallet provider
+    const magicEdenInjectedProvider = getMagicEdenInjectedProvider();
+    if (magicEdenInjectedProvider) {
+        const magicEdenWalletProvider = createMagicEdenBitcoinWalletProvider({
+            dynamicClient: client,
+            satsConnectProvider: magicEdenInjectedProvider
+        });
+        injectedWalletProviders.push(magicEdenWalletProvider);
+    }
     // TODO: create and register OKX wallet provider
     // TODO: create and register Bitget wallet provider
     // TODO: create and register OneKey wallet provider