@dynamic-labs-sdk/bitcoin 0.1.0-alpha.18 → 0.1.0-alpha.20

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.1.0-alpha.20 (2025-10-15)
+
+This was a version bump only, there were no code changes.
+
+## 0.1.0-alpha.19 (2025-10-10)
+
+This was a version bump only, there were no code changes.
+
 ## 0.1.0-alpha.18 (2025-10-08)
 
 ### 🚀 Features

package/addBitcoinInjectedWalletsExtension.cjs.js

@@ -0,0 +1,538 @@
+'use strict';
+
+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 name = "@dynamic-labs-sdk/bitcoin";
+var version = "0.1.0-alpha.20";
+
+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({}, core.createBaseNetworkProvider('BTC', networkData), {
+        getBalance: async ({ address })=>({
+                balance: await fetchBtcBalance({
+                    address
+                })
+            })
+    });
+
+const registerBitcoinNetworkProviderBuilder = (client)=>{
+    const networkProviderBuilderRegistry = core.getNetworkProviderBuilderRegistry(client);
+    /**
+   * If the Bitcoin network provider builder is already registered, return.
+   */ if (networkProviderBuilderRegistry.get().get('BTC')) {
+        return;
+    }
+    networkProviderBuilderRegistry.register({
+        builder: createBitcoinNetworkProvider,
+        chain: 'BTC'
+    });
+};
+
+const PHANTOM_METADATA = {
+    displayName: 'Phantom',
+    icon: `${core.DYNAMIC_ICONIC_SPRITE_URL}#phantom`
+};
+const createPhantomBitcoinWalletProvider = ({ dynamicClient, injectedProvider })=>{
+    const chain = 'BTC';
+    const walletProviderType = sdkApiCore.WalletProviderEnum.BrowserExtension;
+    const key = core.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 ()=>core.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 })=>{
+        core.assertDefined(walletAccount, 'Wallet account not found');
+        await client.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const result = await injectedProvider.signMessage(walletAccount.address, new TextEncoder().encode(message));
+        return {
+            signature: core.getBuffer().from(result.signature).toString('base64')
+        };
+    };
+    const signPsbt = async ({ request, walletAccount })=>{
+        var _request_signature;
+        await client.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const psbtFromBase64 = bitcoinjsLib.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: bitcoinjsLib.Psbt.fromBuffer(signedPsbt).toBase64()
+        };
+    };
+    const signPsbts = async ({ requests, walletAccount })=>{
+        await client.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 } = core.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)
+                });
+            });
+        }
+    });
+    const terminate = async ()=>{
+        cleanupEventEmitter();
+    };
+    return {
+        chain,
+        connect,
+        get events () {
+            return getEventEmitter();
+        },
+        getActiveNetworkId,
+        getConnectedAddresses,
+        groupKey: core.formatWalletProviderGroupKey(PHANTOM_METADATA.displayName),
+        key,
+        metadata: PHANTOM_METADATA,
+        signMessage,
+        signPsbt,
+        signPsbts,
+        terminate,
+        walletProviderType
+    };
+};
+
+const PHANTOM_BITCOIN_PROVIDER_LOCATOR = 'phantom.bitcoin';
+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
+ * 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 UNISAT_METADATA = {
+    displayName: 'UniSat',
+    icon: `${core.DYNAMIC_ICONIC_SPRITE_URL}#unisat`
+};
+const createUnisatWalletProvider = ({ dynamicClient, injectedProvider })=>{
+    const chain = 'BTC';
+    const walletProviderType = sdkApiCore.WalletProviderEnum.BrowserExtension;
+    const key = core.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 ()=>core.getActiveNetworkIdFromLastKnownRegistry({
+            client: dynamicClient,
+            walletProviderKey: key
+        });
+    const getConnectedAddresses = async ()=>{
+        const accounts = await injectedProvider.getAccounts();
+        return {
+            addresses: accounts
+        };
+    };
+    const sendBitcoin = async ({ transaction, walletAccount })=>{
+        await client.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const transactionId = await injectedProvider.sendBitcoin(transaction.recipientAddress, Number(transaction.amount));
+        return {
+            transactionId
+        };
+    };
+    const signMessage = async ({ message, walletAccount, protocol })=>{
+        core.assertDefined(walletAccount, 'Wallet account not found');
+        await client.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const signedMessage = await injectedProvider.signMessage(message, protocol);
+        return {
+            signature: signedMessage
+        };
+    };
+    const signPsbt = async ({ request, walletAccount })=>{
+        await client.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const psbtFromBase64 = bitcoinjsLib.Psbt.fromBase64(request.unsignedPsbtBase64);
+        const signedPsbtHex = await injectedProvider.signPsbt(psbtFromBase64.toHex(), createPsbtOptions({
+            psbt: psbtFromBase64,
+            request
+        }));
+        return {
+            signedPsbt: bitcoinjsLib.Psbt.fromHex(signedPsbtHex).toBase64()
+        };
+    };
+    const signPsbts = async ({ requests, walletAccount })=>{
+        await client.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const psbtHexs = [];
+        const psbtOptions = [];
+        for (const request of requests){
+            const psbtFromBase64 = bitcoinjsLib.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)=>bitcoinjsLib.Psbt.fromHex(signedPsbtHex).toBase64())
+        };
+    };
+    const { getEventEmitter, cleanupEventEmitter } = core.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
+                });
+            });
+        }
+    });
+    const terminate = async ()=>{
+        cleanupEventEmitter();
+    };
+    return {
+        chain,
+        connect,
+        disconnect,
+        get events () {
+            return getEventEmitter();
+        },
+        getActiveNetworkId,
+        getConnectedAddresses,
+        groupKey: core.formatWalletProviderGroupKey(UNISAT_METADATA.displayName),
+        key,
+        metadata: UNISAT_METADATA,
+        sendBitcoin,
+        signMessage,
+        signPsbt,
+        signPsbts,
+        terminate,
+        walletProviderType
+    };
+};
+
+const UNISAT_PROVIDER_LOCATOR = 'unisat';
+const getUnisatInjectedProvider = ()=>{
+    return core.getInjectedProviderFromWindow(UNISAT_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 = core.getDefaultClient())=>{
+    if (core.hasExtension({
+        extensionKey: BITCOIN_INJECTED_WALLETS_EXTENSION_KEY
+    }, client)) {
+        return;
+    }
+    core.registerExtension({
+        extensionKey: BITCOIN_INJECTED_WALLETS_EXTENSION_KEY
+    }, client);
+    registerBitcoinNetworkProviderBuilder(client);
+    const walletProviderRegistry = core.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);
+    }
+    // TODO: create and register MagicEden wallet provider
+    // TODO: create and register Xverse wallet provider
+    // TODO: create and register OKX wallet provider
+    // TODO: create and register Bitget wallet provider
+    // TODO: create and register OneKey wallet provider
+    // TODO: create and register Oyl wallet provider
+    // TODO: create and register Binance wallet provider
+    // TODO: create and register Leather wallet provider
+    injectedWalletProviders.forEach((walletProvider)=>{
+        walletProviderRegistry.register({
+            priority: core.WalletProviderPriority.WINDOW_INJECT,
+            walletProvider
+        });
+    });
+};
+
+exports.InvalidPsbtError = InvalidPsbtError;
+exports.addBitcoinInjectedWalletsExtension = addBitcoinInjectedWalletsExtension;
+exports.getMempoolApiUrl = getMempoolApiUrl;
+exports.name = name;
+exports.version = version;