@multiplechain/bitcoin 0.1.10 → 0.1.12

package/dist/bitcoin-provider.js.LICENSE.txt

@@ -14,6 +14,10 @@
 
 /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
 
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+
+/*! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
+
 /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "namespace": "multiplechain",
   "name": "@multiplechain/bitcoin",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Bitcoin JS provider",
   "scripts": {
     "serve": "parcel test.html --no-cache --dist-dir test",
@@ -34,6 +34,7 @@
     "bignumber.js": "^9.1.1",
     "install": "^0.13.0",
     "npm": "^9.7.2",
+    "sats-connect": "^1.1.1",
     "web3-utils": "^1.8.1",
     "ws": "^8.13.0"
   },

package/src/adapters/leather.js

@@ -0,0 +1,75 @@
+module.exports = leather = (provider) => {
+
+    if (window.crypto && !window.crypto.randomUUID) {
+        window.crypto.randomUUID = () => {
+            let uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+                const r = (Math.random() * 16) | 0;
+                const v = c === 'x' ? r : (r & 0x3) | 0x8;
+                return v.toString(16);
+            });
+            return uuid;
+        };
+    }
+
+    const network =  provider.testnet ? 'testnet' : 'mainnet';
+
+    let wallet = Object.assign({
+        sendBitcoin: (to, amount) => {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    await wallet.request('sendTransfer', {
+                        address: to,
+                        amount,
+                        network
+                    })
+                    .then((response) => {
+                        resolve(response.result.txid);
+                    })
+                    .catch(({error}) => {
+                        reject(error);
+                    });
+                } catch (error) {
+                    reject(error)
+                }
+            });
+        },
+        on: (event, callback) => {
+            if (window.btc && btc.listen) {
+                btc.listen(event, callback);
+            }
+        }
+    }, window.LeatherProvider);
+
+    const connect = async () => {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const addresses = (await wallet.request('getAddresses', {
+                    network
+                })).result.addresses;
+                const bitcoin = addresses.find(address => address.type == 'p2wpkh');
+
+                // for ordinals & BRC-20 integrations
+                // const ordinals = addresses.find(address => address.type == 'p2tr');
+
+                wallet = Object.assign(wallet, window.LeatherProvider);
+                
+                wallet.getAddress = async () => {
+                    return bitcoin.address;
+                }
+
+                resolve(wallet);
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+    return {
+        key: 'leather',
+        name: 'Leather',
+        supports: ['browser'],
+        connect,
+        download: 'https://leather.io/install-extension',
+        detected: Boolean(typeof window.LeatherProvider !== 'undefined')
+    }
+}

package/src/adapters/unisat.js

@@ -1,15 +1,20 @@
 module.exports = unisat = (provider) => {
     
     const wallet = window.unisat;
+    const network =  provider.testnet ? 'testnet' : 'livenet';
+
+    wallet.getAddress = async () => {
+        return (await wallet.getAccounts())[0];
+    }
 
     const connect = async () => {
         return new Promise(async (resolve, reject) => {
             try {
                 wallet.requestAccounts()
                 .then(async () => {
-                    wallet.switchNetwork(provider.network)
+                    wallet.switchNetwork(network)
                     .then(async () => {
-                        resolve((await wallet.getAccounts())[0]);
+                        resolve(wallet);
                     })
                     .catch(error => {
                         reject(error);
@@ -28,7 +33,6 @@ module.exports = unisat = (provider) => {
         key: 'unisat',
         name: 'UniSat',
         supports: ['browser'],
-        wallet,
         connect,
         download: 'https://unisat.io/download',
         detected: Boolean(typeof window.unisat !== 'undefined' && window.unisat.requestAccounts)

package/src/adapters/xverse.js

@@ -0,0 +1,86 @@
+const {getAddress, sendBtcTransaction, BitcoinNetworkType} = require('sats-connect');
+
+module.exports = xverse = (provider) => {
+    
+    const type = provider.testnet ? 
+                    BitcoinNetworkType.Testnet: 
+                    BitcoinNetworkType.Mainnet;
+
+    let wallet = {
+        sendBitcoin: (to, amount) => {
+            return new Promise(async (resolve, reject) => {
+                sendBtcTransaction({
+                    payload: {
+                        network: {
+                            type,
+                        },
+                        recipients: [
+                            {
+                                address: to,
+                                amountSats: BigInt(amount),
+                            }
+                        ],
+                        senderAddress: provider.connectedWallet.connectedAccount,
+                    },
+                    onFinish: (txId) => {
+                        resolve(txId);
+                    },
+                    onCancel: () => {
+                        reject('request-rejected');
+                    }
+                });
+            });
+        },
+        on: (event, callback) => {
+            // TODO: implement
+        }
+    }
+
+    const connect = async () => {
+        return new Promise(async (resolve, reject) => {
+            try {
+                getAddress({
+                    payload: {
+                        purposes: ['ordinals', 'payment'],
+                        message: 'Address for receiving Ordinals and payments',
+                        network: {
+                            type
+                        },
+                    },
+                    onFinish: (response) => {
+                        const addresses = Object.values(response.addresses);
+                        const bitcoin = addresses.find(address => address.purpose == 'payment');
+                        
+                        // for ordinals & BRC-20 integrations
+                        // const ordinals = addresses.find(address => address.purpose == 'ordinals');
+
+                        wallet = Object.assign(wallet, window.XverseProviders.BitcoinProvider);
+                        
+                        wallet.getAddress = async () => {
+                            return bitcoin.address;
+                        }
+
+                        resolve(wallet);
+                    },
+                    onCancel: () => {
+                        reject('request-rejected');
+                    }
+                });
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+    return {
+        key: 'xverse',
+        name: 'Xverse',
+        supports: [
+            'browser',
+            'mobile'
+        ],
+        connect,
+        download: 'https://www.xverse.app/download',
+        detected: Boolean(typeof window.XverseProviders !== 'undefined' && XverseProviders.BitcoinProvider)
+    }
+}

package/src/entity/coin.js

@@ -43,40 +43,13 @@ class Coin {
     /**
      * @returns {Object}
      */
-    async getBalance() {
-        let balance = await this.provider.connectedWallet.wallet.getBalance();
-        return {
-            confirmed: utils.toDec(balance.confirmed, this.getDecimals()),
-            unconfirmed: utils.toDec(balance.unconfirmed, this.getDecimals()),
-            total: utils.toDec(balance.total, this.getDecimals())
-        }
+    async getBalance(address) {
+        let addressStatsApi = this.provider.api + 'address/' + address;
+        let addressStats = await fetch(addressStatsApi).then(res => res.json());
+        let balanceSat = addressStats.chain_stats.funded_txo_sum - addressStats.chain_stats.spent_txo_sum;
+        return utils.toBitcoin(balanceSat);
     }
 
-    /**
-     * @returns {Number}
-     */
-    async getConfirmedBalance() {
-        let balance = await this.getBalance();
-        return balance.confirmed;
-    }
-
-    /**
-     * @returns {Number}
-     */
-    async getUnconfirmedBalance() {
-        let balance = await this.getBalance();
-        return balance.unconfirmed;
-    }
-
-    /**
-     * @returns {Number}
-     */
-    async getTotalBalance() {
-        let balance = await this.getBalance();
-        return balance.total;
-    }
-
-
     /**
      * @param {String} from
      * @param {String} to 
@@ -86,18 +59,14 @@ class Coin {
     transfer(from, to, amount) {
         return new Promise(async (resolve, reject) => {
 
-            if (parseFloat(amount) > await this.getConfirmedBalance(from)) {
+            if (parseFloat(amount) > await this.getBalance(from)) {
                 return reject('insufficient-balance');
             }
 
             amount = utils.toSatoshi(amount);
-            this.provider.connectedWallet.wallet.sendBitcoin(to, amount)
-            .then((txid) => {
-                resolve(txid);
-            })
-            .catch((error) => {
-                reject(error);
-            });
+            
+            // develop for be side
+        
         });
     }
 }

package/src/get-adapter.js

@@ -1,5 +1,7 @@
 const adapters = {
     unisat: require('./adapters/unisat'),
+    xverse: require('./adapters/xverse'),
+    leather: require('./adapters/leather'),
 }
 
 /**

package/src/provider.js

@@ -48,22 +48,33 @@ class Provider {
      */
     connectedWallet;
 
+    /**
+     * @var {String}
+     */
+    blockcypherToken;
+
     /**
      * @param {Object} options 
      */
-    constructor(options) {
+    constructor(options = {}) {
         
         this.testnet = options.testnet;
-        this.network = options.testnet ? 'testnet' : 'livenet';
+        this.network = options.testnet ? 'testnet' : 'mainnet';
+        this.blockcypherToken = options.blockcypherToken;
 
         if (this.testnet) {
             this.api = "https://blockstream.info/testnet/api/";
             this.explorer = "https://blockstream.info/testnet/";
-            this.wsUrl = "wss://socket.blockcypher.com/v1/btc/test3?token=6d9cba333f234b9498473955497c40d9";
+            let token = this.blockcypherToken || "6d9cba333f234b9498473955497c40d9";
+            this.wsUrl = "wss://socket.blockcypher.com/v1/btc/test3?token=" + token;
         } else {
             this.api = "https://blockstream.info/api/";
             this.explorer = "https://blockstream.info/";
-            this.wsUrl = "wss://ws.blockchain.info/inv";
+            if (this.blockcypherToken) {
+                this.wsUrl = "wss://socket.blockcypher.com/v1/btc/main?token=" + this.blockcypherToken;
+            } else {
+                this.wsUrl = "wss://ws.blockchain.info/inv";
+            }
         }
 
         this.detectWallets();
@@ -77,74 +88,62 @@ class Provider {
         let receiver = options.receiver;
         let ws = new WebSocket(this.wsUrl);
 
-        if (this.testnet) {
-            let subscription = {
-                unsubscribe: () => {
-                    ws.close();
-                }
-            }
-    
-            ws.addEventListener('open', () => {
-                ws.send(JSON.stringify({
-                    event: "unconfirmed-tx",
-                    address: receiver,
-                    token: "6d9cba333f234b9498473955497c40d9"
-                }));
-            });
-    
-            let startCallback = async (data) => {
-                try {
-                    let tx = this.Transaction(data.hash);
-                    await tx.getData();
-                    callback(subscription, tx);
-                } catch (error) {
-                    setTimeout(() => {
-                        startCallback(data);
-                    }, 2500);
-                }
-            }
-        
-            ws.addEventListener('message', (res) => {
-                setTimeout(() => {
-                    startCallback(JSON.parse(res.data));
-                }, 6000);
+        let message;
+        if (this.testnet || this.blockcypherToken) {
+            message = JSON.stringify({
+                event: "unconfirmed-tx",
+                address: receiver,
+                token: this.blockcypherToken || "6d9cba333f234b9498473955497c40d9"
             });
         } else {
-            let subscription = {
-                unsubscribe: () => {
+            message = JSON.stringify({
+                "op": "unconfirmed_sub"
+            });
+        }
+
+        let subscription = {
+            unsubscribe: () => {
+                if (!this.testnet && !this.blockcypherToken) {
                     ws.send(JSON.stringify({
-                        "op": "addr_unsub",
-                        "addr": receiver
+                        "op": "unconfirmed_unsub"
                     }));
-                    ws.close();
                 }
+                ws.close();
             }
-            
-            ws.addEventListener('open', () => {
-                ws.send(JSON.stringify({
-                    "op": "addr_sub",
-                    "addr": receiver
-                }));
-            });
+        }
 
-            let startCallback = async (data) => {
-                try {
-                    let tx = this.Transaction(data.x.hash);
-                    await tx.getData();
-                    callback(subscription, tx);
-                } catch (error) {
-                    setTimeout(() => {
-                        startCallback(data);
-                    }, 2500);
-                }
+        let startCallback = async (data) => {
+            try {
+                let tx = this.Transaction(data.hash || data.x.hash);
+                await tx.getData();
+                callback(subscription, tx);
+            } catch (error) {
+                setTimeout(() => {
+                    startCallback(data);
+                }, 2500);
+            }
+        }
+
+        ws.addEventListener('open', () => {
+            ws.send(message);
+        });
+
+        ws.addEventListener('message', (res) => {
+            let result = true;
+            let data = JSON.parse(res.data);
+            
+            if (!this.testnet && !this.blockcypherToken) {
+                result = data.x.out.find(o => {
+                    return String(o.addr).toLowerCase() == receiver.toLowerCase();
+                });
             }
 
-            ws.addEventListener('message', (res) => {
+            if (result) {
                 setTimeout(() => {
-                    startCallback(JSON.parse(res.data));
+                    startCallback(data);
                 }, 6000);
-            });
-        }
+            }
+        });
     }
 
     /**
@@ -167,7 +166,7 @@ class Provider {
                     resolve(wallet);
                 })
                 .catch(error => {
-                    
+                    reject(error);
                 });
             } else {
                 reject('wallet-not-found');
@@ -184,7 +183,9 @@ class Provider {
         const Wallet = require('./wallet');
 
         const wallets = {
-            unisat: new Wallet('unisat', this)
+            unisat: new Wallet('unisat', this),
+            xverse: new Wallet('xverse', this),
+            leather: new Wallet('leather', this),
         };
         
         return Object.fromEntries(Object.entries(wallets).filter(([key]) => {
@@ -209,6 +210,14 @@ class Provider {
             if (typeof window.unisat !== 'undefined' && unisat.requestAccounts) {
                 this.detectedWallets['unisat'] = new Wallet('unisat', this);
             }
+
+            if (typeof window.XverseProviders !== 'undefined' && XverseProviders.BitcoinProvider) {
+                this.detectedWallets['xverse'] = new Wallet('xverse', this);
+            }
+
+            if (typeof window.LeatherProvider !== 'undefined') {
+                this.detectedWallets['leather'] = new Wallet('leather', this);
+            }
         }
     }
 

package/src/utils.js

@@ -8,11 +8,16 @@ module.exports = Object.assign(utils, {
         let value = new BigNumber(amount.toString(10), 10).times(length);
         return parseInt(value.toString(10));
     },
+    toBitcoin(amount) {
+        return parseFloat(amount.toString(10) / 100000000);
+    },
     rejectMessage(error, reject) {
         
         if (typeof error == 'object') {
             if (error.code == 4001 || error.message == 'User rejected the request.') {
                 return reject('request-rejected');
+            } else if (String(error).includes('is not valid JSON')) {
+                return reject('not-accepted-chain');
             }
         }
 

package/src/wallet.js

@@ -37,7 +37,6 @@ class Wallet {
      */
     setAdapter(adapter) {
         this.adapter = getAdapter(adapter, this.provider);
-        this.wallet = this.adapter.wallet;
     }
 
     /**
@@ -88,14 +87,11 @@ class Wallet {
     connect() {
         return new Promise((resolve, reject) => {
             this.adapter.connect()
-            .then(async (connectedAccount) => {
-                let network = await this.wallet.getNetwork();
-                if (this.provider.network == network) {
-                    this.provider.setConnectedWallet(this);
-                    resolve(this.connectedAccount = connectedAccount);
-                } else {
-                    reject('not-accepted-chain');
-                }
+            .then(async (wallet) => {
+                this.wallet = wallet;
+                this.connectedAccount = await wallet.getAddress();
+                this.provider.setConnectedWallet(this);
+                resolve(this.connectedAccount);
             })
             .catch((error) => {
                 utils.rejectMessage(error, reject);
@@ -128,8 +124,13 @@ class Wallet {
         return new Promise(async (resolve, reject) => {
             try {
                 let coin = this.provider.Coin();
-                
-                coin.transfer(this.connectedAccount, to, amount)
+                if (parseFloat(amount) > await coin.getBalance(this.connectedAccount)) {
+                    return reject('insufficient-balance');
+                }
+
+                amount = utils.toSatoshi(amount);
+
+                this.wallet.sendBitcoin(to, amount)
                 .then((transactionId) => {
                     resolve(this.provider.Transaction(transactionId));
                 })