@multiplechain/bitcoin 0.1.1 → 0.1.2

package/package.json

@@ -1,45 +1,45 @@
-{
-  "namespace": "multiplechain",
-  "name": "@multiplechain/bitcoin",
-  "version": "0.1.1",
-  "description": "Bitcoin JS provider",
-  "scripts": {
-    "serve": "parcel test.html --no-cache --dist-dir test",
-    "build": "webpack"
-  },
-  "files": [
-    "src"
-  ],
-  "main": "src/provider.js",
-  "types": "index.d.ts",
-  "typings": "index.d.ts",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/MultipleChain/bitcoin.git"
-  },
-  "keywords": [
-    "Blockchain",
-    "Bitcoin",
-    "Cryptocurrency"
-  ],
-  "author": "MultipleChain",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/MultipleChain/bitcoin/issues"
-  },
-  "homepage": "https://github.com/MultipleChain/bitcoin",
-  "dependencies": {
-    "@multiplechain/utils": "^0.1.1",
-    "bignumber.js": "^9.1.1",
-    "web3-utils": "^1.8.1"
-  },
-  "devDependencies": {
-    "assert": "^2.0.0",
-    "buffer": "^5.7.1",
-    "events": "^3.3.0",
-    "process": "^0.11.10",
-    "stream-browserify": "^3.0.0",
-    "webpack": "^5.76.0",
-    "webpack-cli": "^5.0.1"
-  }
-}
+{
+  "namespace": "multiplechain",
+  "name": "@multiplechain/bitcoin",
+  "version": "0.1.2",
+  "description": "Bitcoin JS provider",
+  "scripts": {
+    "serve": "parcel test.html --no-cache --dist-dir test",
+    "build": "webpack"
+  },
+  "files": [
+    "src"
+  ],
+  "main": "src/bitcoin-provider.js",
+  "types": "index.d.ts",
+  "typings": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MultipleChain/bitcoin.git"
+  },
+  "keywords": [
+    "Blockchain",
+    "Bitcoin",
+    "Cryptocurrency"
+  ],
+  "author": "MultipleChain",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/MultipleChain/bitcoin/issues"
+  },
+  "homepage": "https://github.com/MultipleChain/bitcoin",
+  "dependencies": {
+    "@multiplechain/utils": "^0.1.1",
+    "bignumber.js": "^9.1.1",
+    "web3-utils": "^1.8.1"
+  },
+  "devDependencies": {
+    "assert": "^2.0.0",
+    "buffer": "^5.7.1",
+    "events": "^3.3.0",
+    "process": "^0.11.10",
+    "stream-browserify": "^3.0.0",
+    "webpack": "^5.76.0",
+    "webpack-cli": "^5.0.1"
+  }
+}

package/src/adapters/unisat.js

@@ -0,0 +1,35 @@
+module.exports = unisat = (provider) => {
+    
+    const wallet = window.unisat;
+
+    const connect = async () => {
+        return new Promise(async (resolve, reject) => {
+            try {
+                wallet.requestAccounts()
+                .then(async () => {
+                    wallet.switchNetwork(provider.network)
+                    .then(async () => {
+                        resolve((await wallet.getAccounts())[0]);
+                    })
+                    .catch(error => {
+                        reject(error);
+                    });
+                })
+                .catch(error => {
+                    reject(error);
+                });
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+    return {
+        key: 'unisat',
+        name: 'UniSat',
+        type: 'browser',
+        wallet,
+        connect,
+        download: 'https://unisat.io/download'
+    }
+}

package/src/entity/coin.js

@@ -0,0 +1,105 @@
+const utils = require('../utils');
+
+class Coin {
+
+    /**
+     * @var {String} 
+     */
+    symbol;
+
+    /**
+     * @var {String} 
+     */
+    decimals;
+
+    /**
+     * @var {Provider} 
+     */
+    provider;
+
+    /**
+     * @param {Provider} provider 
+     */
+    constructor(provider) {
+        this.provider = provider;
+        this.decimals = 8;
+        this.symbol = 'BTC';
+    }
+
+    /**
+     * @returns {String}
+     */
+    getSymbol() {
+        return this.symbol;
+    }
+
+    /**
+     * @returns {Integer}
+     */
+    getDecimals() {
+        return this.decimals;
+    }
+
+    /**
+     * @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())
+        }
+    }
+
+    /**
+     * @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 
+     * @param {Number} amount 
+     * @returns {String|Object}
+     */
+    transfer(from, to, amount) {
+        return new Promise(async (resolve, reject) => {
+
+            if (parseFloat(amount) > await this.getConfirmedBalance(from)) {
+                return reject('insufficient-balance');
+            }
+
+            amount = utils.toSatoshi(amount);
+            this.provider.connectedWallet.wallet.sendBitcoin(to, amount)
+            .then((txid) => {
+                resolve(txid);
+            })
+            .catch((error) => {
+                reject(error);
+            });
+        });
+    }
+}
+
+module.exports = Coin;

package/src/entity/token.js

@@ -0,0 +1,5 @@
+class Token {
+    // TODO: Implement this class
+}
+
+module.exports = Token;

package/src/{transaction.js → entity/transaction.js}

@@ -20,7 +20,7 @@ class Transaction {
     /**
      * @var {Number}
      */
-    timer;
+    timer = 30;
 
     /**
      * @param {String} hash 
@@ -49,15 +49,7 @@ class Transaction {
      */
     async getData() {
         try {
-
-            let txApi;
-
-            if (this.provider.testnet) {
-                txApi = this.provider.api + 'tx/' + this.hash;
-            } else {
-                txApi = this.provider.api + 'rawtx/' + this.hash;
-            }
-            
+            let txApi = this.provider.api + 'tx/' + this.hash;
             this.data = await fetch(txApi).then(res => res.json());
         } catch (error) {
             throw new Error('There was a problem retrieving transaction data!');
@@ -72,13 +64,7 @@ class Transaction {
     async getConfirmations() {
         try {
 
-            let blockApi;
-            if (this.provider.testnet) {
-                blockApi = this.provider.api + 'blocks/tip/height';
-            } else {
-                blockApi = this.provider.api + 'latestblock';
-            }
-
+            let blockApi = this.provider.api + 'blocks/tip/height';
             if (!this.data) await this.getData();
             let latestBlock = await fetch(blockApi).then(res => res.json());
 
@@ -86,14 +72,7 @@ class Transaction {
                 latestBlock = latestBlock.height;
             }
 
-            let blockHeight;
-            if (this.provider.testnet) {
-                blockHeight = this.data.status.block_height;
-            } else {
-                blockHeight = this.data.block_height;
-            }
-
-            return ((latestBlock - blockHeight) + 1);
+            return ((latestBlock - (this.data.status.block_height || 0)) + 1);
         } catch (error) {}
     }
 
@@ -133,14 +112,8 @@ class Transaction {
                     if (this.data == null) {
                         result = false;
                     } else {
-                        if (this.provider.testnet) {
-                            if (this.data.status.block_height) {
-                                result = true;
-                            }
-                        } else {
-                            if (this.data.block_height) {
-                                result = true;
-                            }
+                        if (this.data.status.block_height) {
+                            result = true;
                         }
                     }
 
@@ -173,31 +146,15 @@ class Transaction {
 
         if (await this.validateTransaction()) {
 
-            let data;
-            if (this.provider.testnet) {
-
-                let index = this.data.vout.findIndex(object => {
-                    return object.scriptpubkey_address == config.receiver;
-                });
-
-                data = this.data.vout[index];
-                
-                data = {
-                    receiver: data.scriptpubkey_address,
-                    amount: utils.toDec(data.value, 8)
-                };
-            } else {
-                
-                let index = this.data.out.findIndex(object => {
-                    return object.addr == config.receiver;
-                });
+            let index = this.data.vout.findIndex(object => {
+                return object.scriptpubkey_address == config.receiver;
+            });
 
-                data = this.data.out[index];
-
-                data = {
-                    receiver: data.addr,
-                    amount: utils.toDec(data.value, 8)
-                };
+            let data = this.data.vout[index];
+            
+            data = {
+                receiver: data.scriptpubkey_address,
+                amount: utils.toDec(data.value, 8)
             }
 
             if (data.receiver == config.receiver && data.amount == config.amount) {
@@ -214,11 +171,7 @@ class Transaction {
      * @returns {String}
      */
     getUrl() {
-        if (this.provider.testnet) {
-            return this.provider.explorer + 'tx/' + this.hash;
-        } else {
-            return this.provider.explorer + 'transactions/btc/' + this.hash;
-        }
+        return this.provider.explorer + 'tx/' + this.hash;
     }
 }
 

package/src/get-adapter.js

@@ -0,0 +1,11 @@
+const adapters = {
+    unisat: require('./adapters/unisat'),
+}
+
+/**
+ * @param {String} adapter
+ * @param {Object} provider
+ */
+module.exports = getAdapter = (adapter, provider) => {
+    return adapters[adapter](provider);
+}

package/src/provider.js

@@ -1,40 +1,101 @@
-const Transaction = require("./transaction");
 const utils = require("@multiplechain/utils");
+const Coin = require("./entity/coin");
+const Token = require("./entity/token");
+const Transaction = require("./entity/transaction");
 
 class Provider {
 
+    /**
+     * @var {String}
+     */
     api;
 
+    /**
+     * @var {String}
+     */
     explorer;
     
+    /**
+     * @var {Boolean}
+     */
     testnet;
 
+    /**
+     * @var {String}
+     */
+    network;
+
+    /**
+     * @var {Object}
+     */
+    detectedWallets = [];
+
+    /**
+     * @var {Object}
+     */
+    connectedWallet;
+
     constructor(testnet = false) {
         this.testnet = testnet;
+        this.network = testnet ? 'testnet' : 'livenet';
 
         if (!this.testnet) {
-            this.api = "https://blockchain.info/";
-            this.explorer = "https://www.blockchain.com/explorer/";
+            this.api = "https://blockstream.info/api/";
+            this.explorer = "https://blockstream.info/";
         } else {
             this.api = "https://blockstream.info/testnet/api/";
             this.explorer = "https://blockstream.info/testnet/";
         }
+
+        this.detectWallets();
     }
 
     getWalletOpenLink(address, amount) {
         return 'bitcoin' + ':' + String(address).toUpperCase() + '?amount=' + amount;
     }
 
-    async getAddressLastTransaction(receiver) {
-        
-        let apiUrl;
-        if (this.testnet) {
-            apiUrl = this.api + 'address/' + receiver + '/txs';
-        } else {
-            apiUrl = this.api + 'rawaddr/' + receiver;
+    errorCheck(data) {
+        if (typeof data == 'string') {
+            if (data == 'Address on invalid network') {
+                return {
+                    error: 'invalid-address'
+                }
+            } else {
+                return {
+                    error: 'any-error'
+                }
+            }
+        } else if (data.error) {
+            if (data.error == 'not-found-or-invalid-arg') {
+                return {
+                    error: 'invalid-address'
+                }
+            } else {
+                return {
+                    error: 'any-error'
+                }
+            }
         }
 
-        let data = await fetch(apiUrl).then(res => res.json());
+        return data;
+    }
+
+    /**
+     * @param {String} receiver 
+     * @returns 
+     */
+    async getLastTransactionByReceiver(receiver) {
+        
+        let apiUrl = this.api + 'address/' + receiver + '/txs';
+        let data = await fetch(apiUrl).then(response => response.text());
+        try {
+            data = JSON.parse(data);
+        } catch (error) {}
+        
+        data = this.errorCheck(data);
+        if (data.error) {
+            return data;
+        }
 
         if (data.length == 0) {
             return {
@@ -42,38 +103,78 @@ class Provider {
                 amount: 0
             }
         }
+            
+        let tx = data[0];
 
-        if (data.txs) {
+        let index = tx.vout.findIndex(object => {
+            return object.scriptpubkey_address == receiver;
+        });
 
-            let tx = data.txs[0];
+        data = tx.vout[index];
 
-            let index = tx.out.findIndex(object => {
-                return object.addr == receiver;
-            });
+        return {
+            hash: tx.txid,
+            amount: utils.toDec(data.value, 8)
+        };
+    }
 
-            data = tx.out[index];
-            
-            return {
-                hash: tx.hash,
-                amount: utils.toDec(data.value, 8)
+    /**
+     * @param {Wallet} wallet 
+     */
+    setConnectedWallet(wallet) {
+        this.connectedWallet = wallet;
+    }
+
+    /**
+     * @param {String} adapter 
+     * @returns {Promise}
+     */
+    connectWallet(adapter) {
+        return new Promise(async (resolve, reject) => {
+            if (this.detectedWallets[adapter]) {
+                let wallet = this.detectedWallets[adapter];
+                wallet.connect()
+                .then(() => {
+                    resolve(wallet);
+                })
+                .catch(error => {
+                    
+                });
+            } else {
+                reject('wallet-not-found');
             }
-        } else {
-            
-            let tx = data[0];
+        });
+    }
 
-            let index = tx.vout.findIndex(object => {
-                return object.scriptpubkey_address == receiver;
-            });
+    /**
+     * @param {Array} filter 
+     * @returns {Array}
+     */
+    getDetectedWallets(filter) {
+        if (!filter) return this.detectedWallets;
+        return Object.fromEntries(Object.entries(this.detectedWallets).filter(([key]) => {
+            return filter.includes(key);
+        }));
+    }
 
-            data = tx.vout[index];
+    detectWallets() {
+        if (typeof window != 'undefined') {
+            const Wallet = require('./wallet');
 
-            return {
-                hash: tx.txid,
-                amount: utils.toDec(data.value, 8)
-            };
+            if (typeof window.unisat !== 'undefined') {
+                this.detectedWallets['unisat'] = new Wallet('unisat', this);
+            }
         }
     }
 
+    Coin() {
+        return new Coin(this);
+    }
+
+    Token(address) {
+        return new Token(address, this);
+    }
+
     Transaction(hash) {
         return new Transaction(hash, this);
     }

package/src/utils.js

@@ -0,0 +1,21 @@
+const BigNumber = require('bignumber.js');
+const utils = require('@multiplechain/utils');
+
+module.exports = Object.assign(utils, {
+    toSatoshi(amount) {
+        let decimals = 8;
+        let length = '1' + '0'.repeat(decimals);
+        let value = new BigNumber(amount.toString(10), 10).times(length);
+        return parseInt(value.toString(10));
+    },
+    rejectMessage(error, reject) {
+        
+        if (typeof error == 'object') {
+            if (error.code == 4001 || error.message == 'User rejected the request.') {
+                return reject('request-rejected');
+            }
+        }
+
+        return reject(error);
+    }
+})

package/src/wallet.js

@@ -0,0 +1,185 @@
+const getAdapter = require('./get-adapter');
+const utils = require('./utils');
+
+class Wallet {
+
+    /**
+     * @var {Object}
+     */
+    adapter;
+
+    /**
+     * @var {Object}
+     */
+    wallet;
+    
+    /**
+     * @var {Object}
+     */
+    provider;
+    
+    /**
+     * @var {String}
+     */
+    connectedAccount;
+
+    /**
+     * @param {String} adapter 
+     * @param {Object} provider 
+     */
+    constructor(adapter, provider) {
+        this.provider = provider;
+        this.setAdapter(adapter);
+    }
+
+    /**
+     * @param {String} adapter 
+     */
+    setAdapter(adapter) {
+        this.adapter = getAdapter(adapter, this.provider);
+        this.wallet = this.adapter.wallet;
+    }
+
+    /**
+     * @returns {String}
+     */
+    getKey() {
+        return this.adapter.key;
+    }
+
+    /**
+     * @returns {String}
+     */
+    getName() {
+        return this.adapter.name;
+    }
+
+    /**
+     * @returns {String}
+     */
+    getType() {
+        return this.adapter.type;
+    }
+
+    /**
+     * @returns {String}
+     */
+    getDeepLink() {
+        return this.adapter.deepLink;
+    }
+
+    /**
+     * @returns {String}
+     */
+    getDownloadLink() {
+        return this.adapter.download;
+    }
+
+    /**
+     * @returns {String}
+     */
+    connect() {
+        return new Promise((resolve, reject) => {
+            let time = 0;
+            let timeout = 15;
+            let timer = setInterval(async () => {
+                time += 1;
+                if (time > timeout) {
+                    clearInterval(timer);
+                    reject('timeout');
+                }
+            }, 1000);
+
+            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');
+                }
+            })
+            .catch((error) => {
+                utils.rejectMessage(error, reject);
+            })
+            .finally(() => {
+                clearInterval(timer);
+            });
+        });
+    }
+
+    /**
+     * @returns {Array}
+     */
+    getAccounts() {
+        return this.wallet.getAccounts();
+    }
+
+    /**
+     * @returns {String}
+     */
+    getPublicKey() {
+        return this.wallet.getPublicKey();
+    }
+    
+
+    /**
+     * @param {String} to
+     * @param {Integer} amount
+     * @return {Transaction|Object}
+     * @throws {Error}
+     */
+    coinTransfer(to, amount) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                let coin = this.provider.Coin();
+                
+                coin.transfer(this.connectedAccount, to, amount)
+                .then((transactionId) => {
+                    resolve(this.provider.Transaction(transactionId));
+                })
+                .catch((error) => {
+                    utils.rejectMessage(error, reject);
+                });
+            } catch (error) {
+                utils.rejectMessage(error, reject);
+            }
+        });
+    }
+
+    // TODO: implement
+    tokenTransfer(to, amount, tokenAddress) {
+    }
+
+    /**
+     * @param {String} to
+     * @param {Integer} amount
+     * @param {String|null} tokenAddress
+     * @return {Transaction|Object}
+     * @throws {Error}
+     */
+    transfer(to, amount, tokenAddress = null) {
+        if (tokenAddress) {
+            return this.tokenTransfer(to, amount, tokenAddress);
+        } else {
+            return this.coinTransfer(to, amount);
+        }
+    }
+
+    // Events
+    accountsChanged(callback) {
+        this.wallet.on('accountsChanged', (accounts) => {
+            callback(accounts);
+        });
+    }
+
+    networkChanged(callback) {
+        this.wallet.on('networkChanged', (network) => {
+            callback(network);
+        });
+    }
+    
+} 
+
+module.exports = Wallet;