blockchain-api-client
Version:
Blockchain Api Client which maps Results of all supported Blockchain API's into a unified interface
773 lines (662 loc) • 26.8 kB
JavaScript
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
var fetch = _interopDefault(require('node-fetch'));
function _regeneratorRuntime() {
/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
_regeneratorRuntime = function () {
return exports;
};
var exports = {},
Op = Object.prototype,
hasOwn = Op.hasOwnProperty,
$Symbol = "function" == typeof Symbol ? Symbol : {},
iteratorSymbol = $Symbol.iterator || "@@iterator",
asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
function define(obj, key, value) {
return Object.defineProperty(obj, key, {
value: value,
enumerable: !0,
configurable: !0,
writable: !0
}), obj[key];
}
try {
define({}, "");
} catch (err) {
define = function (obj, key, value) {
return obj[key] = value;
};
}
function wrap(innerFn, outerFn, self, tryLocsList) {
var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
generator = Object.create(protoGenerator.prototype),
context = new Context(tryLocsList || []);
return generator._invoke = function (innerFn, self, context) {
var state = "suspendedStart";
return function (method, arg) {
if ("executing" === state) throw new Error("Generator is already running");
if ("completed" === state) {
if ("throw" === method) throw arg;
return doneResult();
}
for (context.method = method, context.arg = arg;;) {
var delegate = context.delegate;
if (delegate) {
var delegateResult = maybeInvokeDelegate(delegate, context);
if (delegateResult) {
if (delegateResult === ContinueSentinel) continue;
return delegateResult;
}
}
if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
if ("suspendedStart" === state) throw state = "completed", context.arg;
context.dispatchException(context.arg);
} else "return" === context.method && context.abrupt("return", context.arg);
state = "executing";
var record = tryCatch(innerFn, self, context);
if ("normal" === record.type) {
if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
return {
value: record.arg,
done: context.done
};
}
"throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
}
};
}(innerFn, self, context), generator;
}
function tryCatch(fn, obj, arg) {
try {
return {
type: "normal",
arg: fn.call(obj, arg)
};
} catch (err) {
return {
type: "throw",
arg: err
};
}
}
exports.wrap = wrap;
var ContinueSentinel = {};
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
var IteratorPrototype = {};
define(IteratorPrototype, iteratorSymbol, function () {
return this;
});
var getProto = Object.getPrototypeOf,
NativeIteratorPrototype = getProto && getProto(getProto(values([])));
NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
function defineIteratorMethods(prototype) {
["next", "throw", "return"].forEach(function (method) {
define(prototype, method, function (arg) {
return this._invoke(method, arg);
});
});
}
function AsyncIterator(generator, PromiseImpl) {
function invoke(method, arg, resolve, reject) {
var record = tryCatch(generator[method], generator, arg);
if ("throw" !== record.type) {
var result = record.arg,
value = result.value;
return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
invoke("next", value, resolve, reject);
}, function (err) {
invoke("throw", err, resolve, reject);
}) : PromiseImpl.resolve(value).then(function (unwrapped) {
result.value = unwrapped, resolve(result);
}, function (error) {
return invoke("throw", error, resolve, reject);
});
}
reject(record.arg);
}
var previousPromise;
this._invoke = function (method, arg) {
function callInvokeWithMethodAndArg() {
return new PromiseImpl(function (resolve, reject) {
invoke(method, arg, resolve, reject);
});
}
return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
};
}
function maybeInvokeDelegate(delegate, context) {
var method = delegate.iterator[context.method];
if (undefined === method) {
if (context.delegate = null, "throw" === context.method) {
if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
}
return ContinueSentinel;
}
var record = tryCatch(method, delegate.iterator, context.arg);
if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
var info = record.arg;
return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
}
function pushTryEntry(locs) {
var entry = {
tryLoc: locs[0]
};
1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
}
function resetTryEntry(entry) {
var record = entry.completion || {};
record.type = "normal", delete record.arg, entry.completion = record;
}
function Context(tryLocsList) {
this.tryEntries = [{
tryLoc: "root"
}], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
}
function values(iterable) {
if (iterable) {
var iteratorMethod = iterable[iteratorSymbol];
if (iteratorMethod) return iteratorMethod.call(iterable);
if ("function" == typeof iterable.next) return iterable;
if (!isNaN(iterable.length)) {
var i = -1,
next = function next() {
for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
return next.value = undefined, next.done = !0, next;
};
return next.next = next;
}
}
return {
next: doneResult
};
}
function doneResult() {
return {
value: undefined,
done: !0
};
}
return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
var ctor = "function" == typeof genFun && genFun.constructor;
return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
}, exports.mark = function (genFun) {
return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
}, exports.awrap = function (arg) {
return {
__await: arg
};
}, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
return this;
}), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
void 0 === PromiseImpl && (PromiseImpl = Promise);
var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
return result.done ? result.value : iter.next();
});
}, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
return this;
}), define(Gp, "toString", function () {
return "[object Generator]";
}), exports.keys = function (object) {
var keys = [];
for (var key in object) keys.push(key);
return keys.reverse(), function next() {
for (; keys.length;) {
var key = keys.pop();
if (key in object) return next.value = key, next.done = !1, next;
}
return next.done = !0, next;
};
}, exports.values = values, Context.prototype = {
constructor: Context,
reset: function (skipTempReset) {
if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
},
stop: function () {
this.done = !0;
var rootRecord = this.tryEntries[0].completion;
if ("throw" === rootRecord.type) throw rootRecord.arg;
return this.rval;
},
dispatchException: function (exception) {
if (this.done) throw exception;
var context = this;
function handle(loc, caught) {
return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
}
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i],
record = entry.completion;
if ("root" === entry.tryLoc) return handle("end");
if (entry.tryLoc <= this.prev) {
var hasCatch = hasOwn.call(entry, "catchLoc"),
hasFinally = hasOwn.call(entry, "finallyLoc");
if (hasCatch && hasFinally) {
if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
} else if (hasCatch) {
if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
} else {
if (!hasFinally) throw new Error("try statement without catch or finally");
if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
}
}
}
},
abrupt: function (type, arg) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
var finallyEntry = entry;
break;
}
}
finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
var record = finallyEntry ? finallyEntry.completion : {};
return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
},
complete: function (record, afterLoc) {
if ("throw" === record.type) throw record.arg;
return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
},
finish: function (finallyLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
}
},
catch: function (tryLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc === tryLoc) {
var record = entry.completion;
if ("throw" === record.type) {
var thrown = record.arg;
resetTryEntry(entry);
}
return thrown;
}
}
throw new Error("illegal catch attempt");
},
delegateYield: function (iterable, resultName, nextLoc) {
return this.delegate = {
iterator: values(iterable),
resultName: resultName,
nextLoc: nextLoc
}, "next" === this.method && (this.arg = undefined), ContinueSentinel;
}
}, exports;
}
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _asyncToGenerator(fn) {
return function () {
var self = this,
args = arguments;
return new Promise(function (resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
function _extends() {
_extends = Object.assign ? Object.assign.bind() : function (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);
}
// TODO Deal with different Blockchains e.g. what if /btc/ should be /eth/
var blockCypherEndpoints = function blockCypherEndpoints(network) {
var networkPath = getNetworkPath(network);
return {
balance: function balance(address) {
return "https://api.blockcypher.com/v1/btc/" + networkPath + "/addrs/" + address + "/full";
},
transactions: function transactions(address, query) {
return "https://api.blockcypher.com/v1/btc/" + networkPath + "/addrs/" + address + "/full?" + query.toString();
},
utxo: function utxo(transactionHash, index) {
return "https://api.blockcypher.com/v1/btc/" + networkPath + "/txs/" + transactionHash + "/" + index;
},
fees: function fees() {
return "https://api.blockcypher.com/v1/btc/" + networkPath;
},
broadcastTransaction: function broadcastTransaction() {
return "https://api.blockcypher.com/v1/btc/" + networkPath + "/txs/push";
}
};
};
var getNetworkPath = function getNetworkPath(network) {
if (network === "MAIN") return "main";
if (network === "TEST") return "test3";
return "test3";
};
var mapBlockCypherBalance = function mapBlockCypherBalance(balance) {
return {
incoming: balance.total_received,
outgoing: balance.total_sent,
unconfirmedBalance: balance.unconfirmed_balance,
confirmedBalance: balance.final_balance
};
};
var mapBlockCypherTransactions = function mapBlockCypherTransactions(transaction) {
return transaction.txs.map(function (transaction, index) {
return {
blockNumber: transaction.block_index,
fee: transaction.fees,
hash: transaction.hash,
hex: transaction.hex || '',
index: index,
inputs: transaction.inputs.map(function (input) {
return {
prevout: {
hash: input.prev_hash,
index: input.output_index
},
sequence: input.sequence,
script: input.script,
scriptType: input.script_type
};
}),
locktime: transaction.lock_time,
outputs: transaction.outputs.map(function (output) {
return {
value: output.value,
script: output.script,
address: output.addresses[0]
};
}),
size: transaction.size,
time: transaction.received.getTime(),
version: transaction.ver,
vsize: transaction.vsize,
total: transaction.total,
witnessHash: transaction.witness_hash || ''
};
});
};
var HttpMethod;
(function (HttpMethod) {
HttpMethod["POST"] = "POST";
HttpMethod["GET"] = "GET";
})(HttpMethod || (HttpMethod = {}));
var fetchFrom = /*#__PURE__*/function () {
var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(url, params) {
var _ref2, body, method, args, response, content;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
_ref2 = params || {}, body = _ref2.body, method = _ref2.method, args = _ref2.args;
_context.next = 3;
return fetch(url, {
method: determineMethod(body, method),
body: JSON.stringify(body),
headers: _extends({
'Content-Type': 'application/json'
}, args == null ? void 0 : args.headers)
});
case 3:
response = _context.sent;
_context.next = 6;
return response.json();
case 6:
content = _context.sent;
if (!response.ok) {
console.error('Error from API, possibly show snackbar', content);
}
return _context.abrupt("return", content);
case 9:
case "end":
return _context.stop();
}
}
}, _callee);
}));
return function fetchFrom(_x, _x2) {
return _ref.apply(this, arguments);
};
}();
var determineMethod = function determineMethod(body, method) {
if (!!method) return method;
if (body) return HttpMethod.POST;
return HttpMethod.GET;
};
var fetchFromBlockCypher = /*#__PURE__*/function () {
var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(url, params) {
var appendix;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
if (!!params && !!params.method && params.method !== HttpMethod.GET) {
appendix = url.includes("?") ? "&" : "?";
url = "" + url + appendix + "token=" + apiKey;
}
return _context.abrupt("return", fetchFrom(url, params));
case 2:
case "end":
return _context.stop();
}
}
}, _callee);
}));
return function fetchFromBlockCypher(_x, _x2) {
return _ref.apply(this, arguments);
};
}();
var apiKey = "2952f06836cf48cc95d998b901c4a4bd ";
// TODO Deal with different Blockchains e.g. what if /btc/ should be /eth/
var tatumEndpoints = {
balance: function balance(address) {
return "https://api-eu1.tatum.io/v3/bitcoin/address/balance/" + address;
},
transactions: function transactions(address, query) {
return "https://api-eu1.tatum.io/v3/bitcoin/transaction/address/" + address + "?" + query.toString();
},
utxo: function utxo(transactionHash, index) {
return "https://api-eu1.tatum.io/v3/bitcoin/utxo/" + transactionHash + "/" + index;
},
fees: function fees() {
return "https://api-eu1.tatum.io/v3/blockchain/estimate";
},
broadcastTransaction: function broadcastTransaction() {
return "https://api-eu1.tatum.io/v3/bitcoin/broadcast";
}
};
var mapTatumBalance = function mapTatumBalance(input) {
return input;
};
var mapTatumTransactions = function mapTatumTransactions(transactions) {
return transactions.map(function (transaction) {
return _extends({}, transaction, {
total: undefined
});
});
};
var fetchFromTatum = /*#__PURE__*/function () {
var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(url, network, params) {
var _params$args;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
return _context.abrupt("return", fetchFrom(url, _extends({}, params, {
args: _extends({}, params == null ? void 0 : params.args, {
headers: _extends({}, params == null ? void 0 : (_params$args = params.args) == null ? void 0 : _params$args.headers, {
"x-api-key": network === "MAIN" ? apiKeys.main : apiKeys.test
})
})
})));
case 1:
case "end":
return _context.stop();
}
}
}, _callee);
}));
return function fetchFromTatum(_x, _x2, _x3) {
return _ref.apply(this, arguments);
};
}();
var apiKeys = {
test: "89156412-0b04-4ed1-aede-d4546b60697c",
main: "4d706557-f378-4242-b57f-78b368df0fc2"
};
var BitcoinProvider;
(function (BitcoinProvider) {
BitcoinProvider[BitcoinProvider["TATUM"] = 0] = "TATUM";
BitcoinProvider[BitcoinProvider["BLOCKCYPHER"] = 1] = "BLOCKCYPHER";
})(BitcoinProvider || (BitcoinProvider = {}));
var BitcoinFactory = function BitcoinFactory(network) {
var _this = this;
this.getProviderFunctions = function (provider) {
switch (provider) {
case BitcoinProvider.TATUM:
return _this.tatum;
case BitcoinProvider.BLOCKCYPHER:
return _this.blockCypher;
default:
return _this.tatum;
}
};
this.blockCypher = {
fetcher: {
fetchBalance: function fetchBalance(address) {
return fetchFromBlockCypher(blockCypherEndpoints(_this.network).balance(address));
},
fetchTransactions: function fetchTransactions(address, query) {
return fetchFromBlockCypher(blockCypherEndpoints(_this.network).transactions(address, query));
}
},
mapper: {
responseToBalance: function responseToBalance(input) {
return mapBlockCypherBalance(input);
},
responseToTransactions: function responseToTransactions(input) {
return mapBlockCypherTransactions(input);
}
}
};
this.tatum = {
fetcher: {
fetchBalance: function fetchBalance(address) {
return fetchFromTatum(tatumEndpoints.balance(address), _this.network);
},
fetchTransactions: function fetchTransactions(address, query) {
return fetchFromTatum(tatumEndpoints.transactions(address, query), _this.network);
}
},
mapper: {
responseToTransactions: function responseToTransactions(input) {
return mapTatumTransactions(input);
},
responseToBalance: function responseToBalance(input) {
return mapTatumBalance(input);
}
}
};
this.network = network;
};
var BitcoinService = function BitcoinService(network) {
var _this = this;
/**
*
* @param address Address of the KeyPair of which we want to know the balance from
* @param provider Which API should be called
* @returns
*/
this.getBalance = /*#__PURE__*/function () {
var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(address, provider) {
var _this$factory$getProv, mapper, fetcher, apiBalance;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
_this$factory$getProv = _this.factory.getProviderFunctions(provider), mapper = _this$factory$getProv.mapper, fetcher = _this$factory$getProv.fetcher;
_context.next = 3;
return fetcher.fetchBalance(address);
case 3:
apiBalance = _context.sent;
return _context.abrupt("return", mapper.responseToBalance(apiBalance));
case 5:
case "end":
return _context.stop();
}
}
}, _callee);
}));
return function (_x, _x2) {
return _ref.apply(this, arguments);
};
}();
/**
*
* @param address Address of the KeyPair of which transactions should be fetched
* @param query Query Parameters for 3rd Party API
* TATUM: https://apidoc.tatum.io/tag/Bitcoin#operation/BtcGetTxByAddress
* BLOCKCYPHER: https://www.blockcypher.com/dev/bitcoin/#address-full-endpoint
* @param provider Which API should be called
* @returns
*/
this.getTransactions = /*#__PURE__*/function () {
var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(address, query, provider) {
var _this$factory$getProv2, mapper, fetcher, apiTransactions;
return _regeneratorRuntime().wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
_this$factory$getProv2 = _this.factory.getProviderFunctions(provider), mapper = _this$factory$getProv2.mapper, fetcher = _this$factory$getProv2.fetcher;
_context2.next = 3;
return fetcher.fetchTransactions(address, query);
case 3:
apiTransactions = _context2.sent;
return _context2.abrupt("return", mapper.responseToTransactions(apiTransactions));
case 5:
case "end":
return _context2.stop();
}
}
}, _callee2);
}));
return function (_x3, _x4, _x5) {
return _ref2.apply(this, arguments);
};
}();
this.factory = new BitcoinFactory(network);
};
exports.BitcoinService = BitcoinService;
//# sourceMappingURL=blockchain-api-client.cjs.development.js.map