@multiplechain/bitcoin 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 MultipleChain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+Preparing

package/package.json

@@ -0,0 +1,45 @@
+{
+  "namespace": "multiplechain",
+  "name": "@multiplechain/bitcoin",
+  "version": "0.1.0",
+  "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"
+  }
+}

package/src/provider.js

@@ -0,0 +1,75 @@
+const Transaction = require("./transaction");
+const utils = require("@multiplechain/utils");
+
+class Provider {
+
+    api;
+
+    explorer;
+    
+    testnet;
+
+    constructor(testnet = false) {
+        this.testnet = testnet;
+
+        if (!this.testnet) {
+            this.api = "https://blockchain.info/";
+            this.explorer = "https://www.blockchain.com/explorer/";
+        } else {
+            this.api = "https://blockstream.info/testnet/api/";
+            this.explorer = "https://blockstream.info/testnet/";
+        }
+    }
+
+    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;
+        }
+
+        let data = await fetch(apiUrl).then(res => res.json());
+
+        if (data.txs) {
+
+            let tx = data.txs[0];
+
+            let index = tx.out.findIndex(object => {
+                return object.addr == receiver;
+            });
+
+            data = tx.out[index];
+            
+            return {
+                hash: tx.hash,
+                amount: utils.toDec(data.value, 8)
+            }
+        } else {
+            
+            let tx = data[0];
+
+            let index = tx.vout.findIndex(object => {
+                return object.scriptpubkey_address == receiver;
+            });
+
+            data = tx.vout[index];
+
+            return {
+                hash: tx.txid,
+                amount: utils.toDec(data.value, 8)
+            };
+        }
+    }
+
+    Transaction(hash) {
+        return new Transaction(hash, this);
+    }
+}
+
+module.exports = Provider;

package/src/transaction.js

@@ -0,0 +1,226 @@
+const utils = require('@multiplechain/utils');
+
+class Transaction {
+
+    /**
+     * @var {Object}
+     */
+    provider;
+
+    /**
+     * @var {String} 
+     */
+    hash;
+
+    /**
+     * @var {Object} 
+     */
+    data;
+
+    /**
+     * @var {Number}
+     */
+    timer;
+
+    /**
+     * @param {String} hash 
+     */
+    constructor(hash, provider) {
+        this.provider = provider;
+        this.hash = hash;
+    }
+
+    /**
+     * @returns {String}
+     */
+    getHash() {
+        return this.hash;
+    }
+
+    /**
+     * @param {Number} timer 
+     */
+    setTimer(timer) {
+        this.timer = timer;
+    }
+    
+    /**
+     * @returns {Object}
+     */
+    async getData() {
+        try {
+
+            let txApi;
+
+            if (this.provider.testnet) {
+                txApi = this.provider.api + 'tx/' + this.hash;
+            } else {
+                txApi = this.provider.api + 'rawtx/' + this.hash;
+            }
+            
+            this.data = await fetch(txApi).then(res => res.json());
+        } catch (error) {
+            throw new Error('There was a problem retrieving transaction data!');
+        }
+
+        return this.data;
+    }
+
+    /** 
+     * @returns {Number}
+     */
+    async getConfirmations() {
+        try {
+
+            let blockApi;
+            if (this.provider.testnet) {
+                blockApi = this.provider.api + 'blocks/tip/height';
+            } else {
+                blockApi = this.provider.api + 'latestblock';
+            }
+
+            if (!this.data) await this.getData();
+            let latestBlock = await fetch(blockApi).then(res => res.json());
+
+            if (typeof latestBlock == 'object') {
+                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);
+        } catch (error) {}
+    }
+
+    /**
+     * @param {Number} confirmations 
+     * @returns {Number}
+     */
+    confirmTransaction(confirmations = 2) {
+        return new Promise((resolve, reject) => {
+            try {
+                this.intervalConfirm = setInterval(async () => {
+                    const trxConfirmations = await this.getConfirmations();
+        
+                    if (trxConfirmations >= confirmations) {
+                        clearInterval(this.intervalConfirm);
+                        return resolve(trxConfirmations);
+                    }
+                }, (this.timer*1000));
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+    /**
+     * @returns {Boolean}
+     */
+    validateTransaction() {
+        return new Promise((resolve, reject) => {
+            this.intervalValidate = setInterval(async () => {
+                try {
+
+                    await this.getData();
+
+                    let result = null;
+
+                    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 (typeof result == 'boolean') {
+                        clearInterval(this.intervalValidate);
+                        if (result == true) {
+                            resolve(true);
+                        } else {
+                            reject(false);
+                        }
+                    }
+    
+                } catch (error) {
+                    if (error.message == 'There was a problem retrieving transaction data!') {
+                        this.validateTransaction();
+                    } else {
+                        clearInterval(this.intervalValidate);
+                        reject(error);
+                    }
+                }
+            }, (this.timer*1000));
+        });
+    }
+
+    /**
+     * @param {String} receiver 
+     * @param {Number} amount 
+     * @returns {Boolean}
+     */
+    async verifyTransferWithData(receiver, amount) {
+
+        if (await this.validateTransaction()) {
+
+            let data;
+            if (this.provider.testnet) {
+
+                let index = this.data.vout.findIndex(object => {
+                    return object.scriptpubkey_address == 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 == receiver;
+                });
+
+                data = this.data.out[index];
+
+                data = {
+                    receiver: data.addr,
+                    amount: utils.toDec(data.value, 8)
+                };
+            }
+
+            if (data.receiver == receiver && data.amount == amount) {
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * @returns {String}
+     */
+    getUrl() {
+        if (this.provider.testnet) {
+            return this.provider.explorer + 'tx/' + this.hash;
+        } else {
+            return this.provider.explorer + 'transactions/btc/' + this.hash;
+        }
+    }
+}
+
+module.exports = Transaction;