beignet 0.0.1

package/src/utils/conversion.ts

@@ -0,0 +1,88 @@
+import { default as bitcoinUnits } from 'bitcoin-units';
+import { EUnit } from '../types';
+
+/**
+ * Converts a value in BTC to satoshis
+ * @param {number} value
+ * @returns {number}
+ */
+export const btcToSats = (value: number): number => {
+	try {
+		return Number(bitcoinUnits(value, 'BTC').to('satoshi').value().toFixed(0));
+	} catch {
+		return 0;
+	}
+};
+
+/**
+ * Converts a value in satoshis to BTC
+ * @param {number} value
+ * @returns {number}
+ */
+export const satsToBtc = (value: number): number => {
+	return bitcoinUnits(value, 'sats').to('BTC').value();
+};
+
+/**
+ * Converts an amount of currency in a specific unit to satoshis
+ * @param {number} value
+ * @param {EUnit} unit
+ * @param {number} exchangeRate
+ * @param {string} currency
+ */
+export const convertToSats = (
+	value: number | string,
+	unit: EUnit,
+	exchangeRate: number,
+	currency = 'EUR'
+): number => {
+	const amount = Number(value);
+
+	if (unit === EUnit.BTC) {
+		return btcToSats(amount);
+	}
+
+	if (unit === EUnit.fiat) {
+		return fiatToBitcoinUnit({
+			fiatValue: amount,
+			unit: EUnit.satoshi,
+			exchangeRate,
+			currency
+		});
+	}
+
+	return amount;
+};
+
+/**
+ * Converts a fiat value to a bitcoin unit.
+ * @param {string | number} fiatValue
+ * @param {number} exchangeRate
+ * @param {string} currency
+ * @param {EUnit} unit
+ * @returns {number}
+ */
+export const fiatToBitcoinUnit = ({
+	fiatValue,
+	exchangeRate,
+	currency,
+	unit
+}: {
+	fiatValue: string | number;
+	exchangeRate: number;
+	currency: string;
+	unit: EUnit;
+}): number => {
+	try {
+		// this throws if exchangeRate is 0
+		bitcoinUnits.setFiat(currency, exchangeRate);
+		const value = bitcoinUnits(Number(fiatValue), currency)
+			.to(unit)
+			.value()
+			.toFixed(unit === EUnit.satoshi ? 0 : 8); // satoshi cannot be a fractional number
+
+		return Number(value);
+	} catch {
+		return 0;
+	}
+};

package/src/utils/derivation-path.ts

@@ -0,0 +1,171 @@
+import {
+	EAddressType,
+	EAvailableNetworks,
+	IKeyDerivationPath,
+	TKeyDerivationAccount,
+	TKeyDerivationChange,
+	TKeyDerivationCoinType,
+	TKeyDerivationPurpose
+} from '../types';
+import { addressTypes } from '../shapes';
+import { err, ok, Result } from './result';
+
+/**
+ * Parses a key derivation path in string format Ex: "m/84'/0'/0'/0/0" and returns IKeyDerivationPath.
+ * @param {string} keyDerivationPath
+ * @param {TKeyDerivationPurpose | string} [purpose]
+ * @param {boolean} [changeAddress]
+ * @param {string} [index]
+ * @param {TAvailableNetworks} [network]
+ * @returns {Result<IKeyDerivationPath>}
+ */
+export const getKeyDerivationPathObject = ({
+	path = '',
+	purpose,
+	changeAddress,
+	index,
+	network
+}: {
+	path: string;
+	purpose?: TKeyDerivationPurpose;
+	changeAddress?: boolean;
+	index?: string;
+	network: EAvailableNetworks;
+}): Result<IKeyDerivationPath> => {
+	try {
+		const parsedPath = path.replace(/'/g, '').split('/');
+
+		if (!purpose) {
+			purpose = parsedPath[1] as TKeyDerivationPurpose;
+		}
+
+		let coinType = parsedPath[2] as TKeyDerivationCoinType;
+		if (network) {
+			coinType =
+				network.toLocaleLowerCase() === EAvailableNetworks.bitcoin ? '0' : '1';
+		}
+
+		const account = parsedPath[3] as TKeyDerivationAccount;
+
+		let change = parsedPath[4] as TKeyDerivationChange;
+		if (changeAddress !== undefined) {
+			change = changeAddress ? '1' : '0';
+		}
+
+		if (!index) {
+			index = parsedPath[5];
+		}
+
+		return ok({
+			purpose,
+			coinType,
+			account,
+			change,
+			index
+		});
+	} catch (e) {
+		return err(e);
+	}
+};
+
+/**
+ * Parses a key derivation path object and returns it in string format. Ex: "m/84'/0'/0'/0/0"
+ * @param {IKeyDerivationPath} path
+ * @param {TKeyDerivationPurpose | string} [purpose]
+ * @param {boolean} [changeAddress]
+ * @param {number} [accountType]
+ * @param {string} [addressIndex]
+ * @returns {Result<string>}
+ */
+export const getKeyDerivationPathString = ({
+	addressType = EAddressType.p2wpkh,
+	path,
+	purpose,
+	accountType,
+	changeAddress = false,
+	index = '0',
+	network
+}: {
+	addressType: EAddressType;
+	path?: IKeyDerivationPath;
+	purpose?: TKeyDerivationPurpose;
+	accountType?: string | number;
+	changeAddress?: boolean;
+	index?: string | number;
+	network: EAvailableNetworks;
+}): Result<string> => {
+	try {
+		if (!path) {
+			// Get default path object for the network and set it from there.
+			const str = addressTypes[addressType].path;
+			const res = getKeyDerivationPathObject({ path: str, network });
+			if (res.isErr()) {
+				return err(res.error.message);
+			}
+			path = res.value;
+		}
+		//Specifically specifying purpose will override the default accountType purpose value.
+		if (purpose !== undefined) {
+			path.purpose = purpose;
+		}
+
+		path.coinType =
+			network.toLocaleLowerCase() === EAvailableNetworks.bitcoin ? '0' : '1';
+
+		if (accountType !== undefined) {
+			if (typeof accountType === 'number') {
+				path.account = String(accountType);
+			}
+			path.account =
+				typeof accountType === 'number' ? String(accountType) : accountType;
+		} else {
+			path.account = '0';
+		}
+
+		path.change = changeAddress ? '1' : '0';
+
+		if (!index) {
+			index = '0';
+		}
+		if (typeof index === 'number') {
+			index = String(index);
+		}
+
+		return ok(
+			`m/${path.purpose}'/${path.coinType}'/${path.account}'/${path.change}/${index}`
+		);
+	} catch (e) {
+		return err(e);
+	}
+};
+
+/**
+ * Returns the address type from the specified derivation path.
+ * @param {string | IKeyDerivationPath} path
+ * @returns {Result<EAddressType>}
+ */
+export const getAddressTypeFromPath = (
+	path: string | IKeyDerivationPath
+): Result<EAddressType> => {
+	try {
+		let purpose;
+		if (typeof path === 'object') {
+			purpose = path.purpose;
+		} else if (typeof path === 'string') {
+			const parsedPathString = path.replace(/'/g, '').split('/');
+			purpose = parsedPathString[1];
+		}
+		switch (purpose) {
+			case '44':
+				return ok(EAddressType.p2pkh);
+			case '49':
+				return ok(EAddressType.p2sh);
+			case '84':
+				return ok(EAddressType.p2wpkh);
+			default:
+				return err('Invalid path');
+		}
+	} catch (e) {
+		return err(e);
+	}
+};

package/src/utils/electrum.ts

@@ -0,0 +1,188 @@
+import * as electrum from 'rn-electrum-client/helpers';
+import { err, ok, Result } from './result';
+
+import {
+	EAvailableNetworks,
+	ElectrumConnectionPubSub,
+	ElectrumConnectionSubscription,
+	IFormattedPeerData,
+	TProtocol
+} from '../types';
+import * as hardcodedPeers from 'rn-electrum-client/helpers/peers.json';
+
+const POLLING_INTERVAL = 1000 * 20;
+export const defaultElectrumPorts = ['51002', '50002', '51001', '50001'];
+
+/**
+ * Returns the default port for the given network and protocol.
+ * @param {EAvailableNetworks} [selectedNetwork]
+ * @param {string} [protocol]
+ * @returns {number}
+ */
+export const getDefaultPort = (
+	selectedNetwork: EAvailableNetworks,
+	protocol: TProtocol
+): number => {
+	if (protocol === 'ssl') {
+		return selectedNetwork === 'testnet' ? 51002 : 50002;
+	} else {
+		return selectedNetwork === 'testnet' ? 51001 : 50001;
+	}
+};
+
+/**
+ * Returns the protocol for the given network and default port.
+ * @param {string} [port]
+ * @param {EAvailableNetworks} [network]
+ * @returns {TProtocol | undefined}
+ */
+export const getProtocolForPort = (
+	port: string,
+	network: EAvailableNetworks
+): TProtocol | undefined => {
+	if (port === '443') {
+		return 'ssl';
+	}
+
+	if (network === 'testnet') {
+		return port === '51002' ? 'ssl' : 'tcp';
+	}
+
+	return port === '50002' ? 'ssl' : 'tcp';
+};
+
+/**
+ * Formats the peer data response from an Electrum server.
+ * @param {[string, string, [string, string, string]]} data
+ * @returns Result<IFormattedPeerData>
+ */
+export const formatPeerData = (
+	data: [string, string, [string, string, string]]
+): Result<IFormattedPeerData> => {
+	try {
+		if (!data) {
+			return err('No data provided.');
+		}
+		if (data?.length !== 3) {
+			return err('Invalid peer data');
+		}
+		if (data[2]?.length < 2) {
+			return err('Invalid peer data');
+		}
+		const [ip, host, ports] = data;
+		const [version, ssl, tcp] = ports;
+		return ok({
+			ip,
+			host,
+			version,
+			ssl,
+			tcp
+		});
+	} catch (e) {
+		if (typeof e === 'string' || e instanceof Error) {
+			return err(e);
+		}
+		return err('Unable to format peer data.');
+	}
+};
+
+/**
+ * Returns an array of peers.
+ * If unable to acquire peers from an Electrum server the method will default to the hardcoded peers in peers.json.
+ * @param {EAvailableNetworks} [selectedNetwork]
+ * @returns Promise<Result<IFormattedPeerData[]>>
+ */
+export const getPeers = async ({
+	selectedNetwork
+}: {
+	selectedNetwork: EAvailableNetworks;
+}): Promise<Result<IFormattedPeerData[]>> => {
+	try {
+		const response = await electrum.getPeers({ network: selectedNetwork });
+		if (!response.error) {
+			// Return an array of peers provided by the currently connected electrum server.
+			const peers: IFormattedPeerData[] = [];
+			await Promise.all(
+				response.data.map(async (peer) => {
+					const formattedPeer = await formatPeerData(peer);
+					if (formattedPeer.isOk()) {
+						peers.push(formattedPeer.value);
+					}
+				})
+			);
+			if (peers?.length > 0) {
+				return ok(peers);
+			}
+		}
+		// No peers available grab hardcoded peers instead.
+		return ok(hardcodedPeers[selectedNetwork]);
+	} catch (e) {
+		if (typeof e === 'string' || e instanceof Error) {
+			return err(e);
+		}
+		return err('Unable to get peers.');
+	}
+};
+
+/**
+ * Background task that checks the connection to the Electrum server with a PubSub
+ * If connection was lost this will try to reconnect in the specified interval
+ * @param {() => Result<null>} [connectToElectrum]
+ * @returns {ElectrumConnectionPubSub}
+ */
+export const electrumConnection = ((
+	connectToElectrum?: () => Result<null>
+): ElectrumConnectionPubSub => {
+	const subscribers: Set<(isConnected: boolean) => void> = new Set();
+	let latestState: boolean | null = null;
+
+	setInterval(async () => {
+		try {
+			const { error } = await electrum.pingServer();
+
+			if (error) {
+				if (connectToElectrum) {
+					console.log('Connection to Electrum Server lost, reconnecting...');
+					const response = await connectToElectrum();
+
+					if (response.isErr()) {
+						electrumConnection.publish(false);
+					}
+				}
+			} else {
+				electrumConnection.publish(true);
+			}
+		} catch (e) {
+			console.error(e);
+		}
+	}, POLLING_INTERVAL);
+
+	const publish = (isConnected: boolean): void => {
+		// Skip if no subscribers
+		if (subscribers.size === 0) {
+			return;
+		}
+
+		// Skip if state hasn't changed
+		if (latestState === isConnected) {
+			return;
+		}
+
+		latestState = isConnected;
+		subscribers.forEach((callback) => callback(isConnected));
+	};
+
+	const subscribe = (
+		callback: (isConnected: boolean) => void
+	): ElectrumConnectionSubscription => {
+		subscribers.add(callback);
+
+		return {
+			remove: (): void => {
+				subscribers.delete(callback);
+			}
+		};
+	};
+
+	return { publish, subscribe };
+})();

package/src/utils/exchange-rate.ts

@@ -0,0 +1,70 @@
+import { ok, err, Result } from './result';
+import { BLOCKTANK_HOST } from '../wallet/constants';
+import { IExchangeRates } from '../types';
+
+export const mostUsedExchangeTickers = {
+	USD: {
+		currencySymbol: '$',
+		quote: 'USD',
+		quoteName: 'US Dollar'
+	},
+	GBP: {
+		currencySymbol: '£',
+		quote: 'GBP',
+		quoteName: 'Great British Pound'
+	},
+	CAD: {
+		currencySymbol: '$',
+		quote: 'CAD',
+		quoteName: 'Canadian Dollar'
+	},
+	CNY: {
+		currencySymbol: '¥',
+		quote: 'CNY',
+		quoteName: 'Chinese Yuan Renminbi'
+	},
+	EUR: { currencySymbol: '€', quote: 'EUR', quoteName: 'Euro' }
+};
+
+type TTicker = {
+	symbol: string;
+	lastPrice: string;
+	base: string;
+	baseName: string;
+	quote: string;
+	quoteName: string;
+	currencySymbol: string;
+	currencyFlag: string;
+	lastUpdatedAt: number;
+};
+
+/**
+ * Returns the exchange rate for the given currency
+ * @returns {Promise<Result<IExchangeRates>>}
+ */
+export const getExchangeRates = async (): Promise<Result<IExchangeRates>> => {
+	try {
+		const response = await fetch(`${BLOCKTANK_HOST}/fx/rates/btc`);
+		const { tickers } = await response.json();
+
+		const rates: IExchangeRates = tickers.reduce(
+			(acc: IExchangeRates, ticker: TTicker) => {
+				return {
+					...acc,
+					[ticker.quote]: {
+						currencySymbol: ticker.currencySymbol,
+						quote: ticker.quote,
+						quoteName: ticker.quoteName,
+						rate: Math.round(Number(ticker.lastPrice) * 100) / 100,
+						lastUpdatedAt: ticker.lastUpdatedAt
+					}
+				};
+			},
+			{}
+		);
+
+		return ok(rates);
+	} catch (e) {
+		return err(e);
+	}
+};

package/src/utils/helpers.ts

@@ -0,0 +1,191 @@
+import { EAddressType, EAvailableNetworks, IKeyDerivationPath } from '../types';
+import { address as bitcoinJSAddress, Network, networks } from 'bitcoinjs-lib';
+import bip39 = require('bip39');
+import * as bitcoin from 'bitcoinjs-lib';
+import { availableNetworks, isValidBech32mEncodedString } from './wallet';
+import { err, ok, Result } from './result';
+import { addressTypes } from '../shapes';
+import { getKeyDerivationPathObject } from './derivation-path';
+
+/**
+ * Get address for a given scriptPubKey.
+ * @param scriptPubKey
+ * @param selectedNetwork
+ * @returns {string}
+ */
+export const getAddressFromScriptPubKey = (
+	scriptPubKey: string,
+	selectedNetwork: EAvailableNetworks
+): string => {
+	const network = networks[selectedNetwork];
+	return bitcoin.address.fromOutputScript(
+		Buffer.from(scriptPubKey, 'hex'),
+		network
+	);
+};
+
+/**
+ * Get sha256 hash of a given string.
+ * @param {string} str
+ * @returns {string}
+ */
+export const getSha256 = (str: string): string => {
+	const buffer = Buffer.from(str, 'utf8');
+	const hash = bitcoin.crypto.sha256(buffer);
+	return hash.toString('hex');
+};
+
+/**
+ * Validate address for a given network.
+ * If no address is provided, it will attempt to validate the address for all available networks.
+ * @param {string} address
+ * @param {EAvailableNetworks} network
+ * @returns {{isValid: boolean, network: EAvailableNetworks}}
+ */
+export const validateAddress = ({
+	address,
+	network
+}: {
+	address: string;
+	network?: EAvailableNetworks;
+}): {
+	isValid: boolean;
+	network: EAvailableNetworks;
+} => {
+	try {
+		//Validate address for all available networks
+		let isValid = false;
+		const availableNetworksList = availableNetworks();
+
+		//Validate address for a specific network
+		if (network !== undefined) {
+			try {
+				bitcoinJSAddress.toOutputScript(address, networks[network]);
+				return { isValid: true, network };
+			} catch {
+				// In the event the normal check fails, determine if this is a taproot address.
+				const taprootRes = isValidBech32mEncodedString(address);
+				if (taprootRes.isValid && taprootRes.network === network) {
+					return { isValid: taprootRes.isValid, network: taprootRes.network };
+				}
+			}
+			return { isValid: false, network };
+		}
+
+		for (let i = 0; i < availableNetworksList.length; i++) {
+			const validateRes = validateAddress({
+				address,
+				network: availableNetworksList[i]
+			});
+			if (validateRes.isValid) {
+				isValid = validateRes.isValid;
+				network = validateRes.network;
+				break;
+			}
+		}
+		return { isValid, network: network ?? EAvailableNetworks.bitcoin };
+	} catch {
+		return { isValid: false, network: EAvailableNetworks.bitcoin };
+	}
+};
+
+/**
+ * Returns the derivation path object for the specified addressType and network.
+ * @param {EAddressType} addressType
+ * @param {EAvailableNetworks} [selectedNetwork]
+ * @returns Result<IKeyDerivationPath>
+ */
+export const getKeyDerivationPath = ({
+	addressType,
+	network
+}: {
+	addressType: EAddressType;
+	network: EAvailableNetworks;
+}): Result<IKeyDerivationPath> => {
+	try {
+		const keyDerivationPathResponse = getKeyDerivationPathObject({
+			network,
+			path: addressTypes[addressType].path
+		});
+		if (keyDerivationPathResponse.isErr()) {
+			return err(keyDerivationPathResponse.error.message);
+		}
+		return ok(keyDerivationPathResponse.value);
+	} catch (e) {
+		return err(e);
+	}
+};
+
+/**
+ * Get scriptHash for a given address
+ * @param {string} address
+ * @param {EAvailableNetworks} network
+ * @returns {string}
+ */
+export const getScriptHash = ({
+	address,
+	network
+}: {
+	address: string;
+	network: EAvailableNetworks;
+}): string => {
+	try {
+		const _network: Network = bitcoin.networks[network];
+		const script = bitcoin.address.toOutputScript(address, _network);
+		const hash = bitcoin.crypto.sha256(script);
+		const reversedHash = Buffer.from(hash.reverse());
+		return reversedHash.toString('hex');
+	} catch {
+		return '';
+	}
+};
+
+/**
+ * Extends bip39's generateMnemonic function.
+ * @param {number} [strength]
+ * @param {(size: number) => Buffer} [rng]
+ * @param {string[]} [wordlist]
+ * @returns {string}
+ */
+export const generateMnemonic = (
+	strength?: number,
+	rng?: (size: number) => Buffer,
+	wordlist?: string[]
+): string => {
+	return bip39.generateMnemonic(strength, rng, wordlist);
+};
+
+/**
+ * Attempts to validate the provided mnemonic.
+ * @param {string} mnemonic
+ * @returns {boolean}
+ */
+export const validateMnemonic = (mnemonic = ''): boolean => {
+	try {
+		return bip39.validateMnemonic(mnemonic);
+	} catch {
+		return false;
+	}
+};
+
+/**
+ * Determines if the two objects passed as params match.
+ * @param obj1
+ * @param obj2
+ * @returns boolean
+ */
+export const objectsMatch = (obj1, obj2): boolean => {
+	if (!obj1 || !obj2) {
+		return false;
+	}
+	const obj1Length = Object.keys(obj1).length;
+	const obj2Length = Object.keys(obj2).length;
+
+	if (obj1Length === obj2Length) {
+		return Object.keys(obj1).every(
+			(key) => key in obj2 && obj2[key] === obj1[key]
+		);
+	} else {
+		return false;
+	}
+};

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+export * from './wallet';
+export * from './helpers';
+export * from './exchange-rate';
+export * from './electrum';
+export * from './derivation-path';
+export * from './transaction';
+export * from './result';