tf-checkout-react 1.3.46 → 1.3.47-beta.2

package/src/components/ticketsContainer/crypto.js

@@ -0,0 +1,528 @@
+import detectEthereumProvider from '@metamask/detect-provider'
+import _get from "lodash/get"
+import Web3 from 'web3'
+
+import { authorizeWithWallet, cryptoA0K1, cryptoAccount, cryptoAddress, cryptoConnect } from "../../api"
+
+const EthereumWrapper = function (exceptionHandler, errorCodes) {
+	let web3
+	const ERRORS = errorCodes
+	let selectedAddress = undefined
+
+	const isSupported = function () {
+		return new Promise(success => {
+			detectEthereumProvider().then(provider => {
+				if (provider) {
+					success(true)
+				} else {
+					success(false)
+				}
+			}).catch(() => success(false))
+		})
+	}
+
+	const enable = function () {
+		return new Promise((success, reject) => {
+			window.ethereum.request({ method: 'eth_requestAccounts' }).then(() => {
+				web3 = new Web3(window.ethereum)
+				success(true)
+			}).catch(error => {
+				let errorCode = ERRORS.WEB3_ERROR
+				if (error.code === 4001) {
+					errorCode = ERRORS.CONNECTION_REJECTED
+				}
+				reject(exceptionHandler('web3js', error.message, '', errorCode))
+			})
+		})
+	}
+
+	const getAddress = function () {
+		return web3.eth.getCoinbase().then(address => {
+			selectedAddress = address
+			return address
+		}).catch(error => Promise.reject(exceptionHandler('web3js', error.message, '', error.WEB3_ERROR)))
+	}
+
+	const getSignature = function (address, nonce, message) {
+		return new Promise((success, reject) => {
+			web3.eth.personal.sign(message + nonce, address, '', (error, result) => {
+
+				if (error) {
+					let errorCode = ERRORS.WEB3_ERROR
+					if (error.code === 4001) {
+						errorCode = ERRORS.SIGNATURE_REJECTED
+					}
+					reject(exceptionHandler('web3js', error.message, '', errorCode))
+				} else {
+					success(result)
+				}
+			})
+		})
+	}
+
+	const getA0k1verseNFTs = function (address, ticketHash, amount) {
+		return new Promise(async (success, reject) => {
+			try {
+				const response = await cryptoA0K1(address, ticketHash, amount)
+				success(_get(response, 'data.data'))
+			} catch(error) {
+				let message = _get(error, 'response.data.message')
+				const statusCode = _get(error, 'response.status')
+				if (!message) {
+					message = _get(error, 'response.statusText')
+				}
+				let errorCode = ERRORS.SERVER_ERROR
+				if (statusCode === 404) {
+					errorCode = ERRORS.TICKET_TYPE_NOT_FOUND
+				}
+				reject(exceptionHandler('backend', message, '', errorCode))
+			}
+		})
+	}
+
+	const hasAccountChanged = function () {
+		const currentAccount = selectedAddress
+		return getAddress().then(address => Promise.resolve(currentAccount !== address))
+	}
+
+	return {
+		isSupported,
+		enable,
+		getAddress,
+		getSignature,
+		getA0k1verseNFTs,
+		hasAccountChanged,
+		ERRORS,
+	}
+}
+
+const SolanaWrapper = function (exceptionHandler, errorCodes) {
+	let solana
+	const ERRORS = errorCodes
+	let publicKey = undefined
+
+	const ByteBase64Converter = function (){
+		/*
+		MIT License
+
+		Copyright (c) 2020 Egor Nepomnyaschih
+
+		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.
+		*/
+
+		/*
+		// This constant can also be computed with the following algorithm:
+		const base64abc = [],
+			A = 'A'.charCodeAt(0),
+			a = 'a'.charCodeAt(0),
+			n = '0'.charCodeAt(0);
+		for (let i = 0; i < 26; ++i) {
+			base64abc.push(String.fromCharCode(A + i));
+		}
+		for (let i = 0; i < 26; ++i) {
+			base64abc.push(String.fromCharCode(a + i));
+		}
+		for (let i = 0; i < 10; ++i) {
+			base64abc.push(String.fromCharCode(n + i));
+		}
+		base64abc.push('+');
+		base64abc.push('/');
+		*/
+		const base64abc = [
+			'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+			'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+			'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+			'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+			'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
+		]
+
+		/*
+		// This constant can also be computed with the following algorithm:
+		const l = 256, base64codes = new Uint8Array(l);
+		for (let i = 0; i < l; ++i) {
+			base64codes[i] = 255; // invalid character
+		}
+		base64abc.forEach((char, index) => {
+			base64codes[char.charCodeAt(0)] = index;
+		});
+		base64codes['='.charCodeAt(0)] = 0; // ignored anyway, so we just need to prevent an error
+		*/
+		const base64codes = [
+			255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+			255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+			255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63,
+			52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, 255, 0, 255, 255,
+			255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+			15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255,
+			255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+			41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
+		]
+
+		function getBase64Code(charCode) {
+			if (charCode >= base64codes.length) {
+				throw new Error('Unable to parse base64 string.')
+			}
+			const code = base64codes[charCode]
+			if (code === 255) {
+				throw new Error('Unable to parse base64 string.')
+			}
+			return code
+		}
+
+		function bytesToBase64(bytes) {
+			let result = ''; let i; const l = bytes.length
+			for (i = 2; i < l; i += 3) {
+				result += base64abc[bytes[i - 2] >> 2]
+				result += base64abc[((bytes[i - 2] & 0x03) << 4) | (bytes[i - 1] >> 4)]
+				result += base64abc[((bytes[i - 1] & 0x0F) << 2) | (bytes[i] >> 6)]
+				result += base64abc[bytes[i] & 0x3F]
+			}
+			if (i === l + 1) { // 1 octet yet to write
+				result += base64abc[bytes[i - 2] >> 2]
+				result += base64abc[(bytes[i - 2] & 0x03) << 4]
+				result += '=='
+			}
+			if (i === l) { // 2 octets yet to write
+				result += base64abc[bytes[i - 2] >> 2]
+				result += base64abc[((bytes[i - 2] & 0x03) << 4) | (bytes[i - 1] >> 4)]
+				result += base64abc[(bytes[i - 1] & 0x0F) << 2]
+				result += '='
+			}
+			return result
+		}
+
+		function base64ToBytes(str) {
+			if (str.length % 4 !== 0) {
+				throw new Error('Unable to parse base64 string.')
+			}
+			const index = str.indexOf('=')
+			if (index !== -1 && index < str.length - 2) {
+				throw new Error('Unable to parse base64 string.')
+			}
+			const missingOctets = str.endsWith('==') ? 2 : str.endsWith('=') ? 1 : 0
+				const n = str.length
+				const result = new Uint8Array(3 * (n / 4))
+				let buffer
+			for (let i = 0, j = 0; i < n; i += 4, j += 3) {
+				buffer =
+					(getBase64Code(str.charCodeAt(i)) << 18) |
+					(getBase64Code(str.charCodeAt(i + 1)) << 12) |
+					(getBase64Code(str.charCodeAt(i + 2)) << 6) |
+					getBase64Code(str.charCodeAt(i + 3))
+				result[j] = buffer >> 16
+				result[j + 1] = (buffer >> 8) & 0xFF
+				result[j + 2] = buffer & 0xFF
+			}
+			return result.subarray(0, result.length - missingOctets)
+		}
+
+		function base64encode(str, encoder) {
+			return bytesToBase64(encoder.encode(str))
+		}
+
+		function base64decode(str, decoder) {
+			return decoder.decode(base64ToBytes(str))
+		}
+
+		return {
+			bytesToBase64,
+			base64encode,
+			base64decode,
+			getBase64Code
+		}
+
+	}
+
+	const isSupported = function () {
+		return new Promise(success => {
+			let solanaLoaded = false
+			const solanaDetection = function() {
+				if(window.solana !== undefined) {
+					solanaLoaded = true;
+					({ solana } = window)
+					success(true)
+				}
+			}
+			window.addEventListener('load', solanaDetection)
+			setTimeout(() => {
+				window.removeEventListener('load', solanaDetection)
+				if(!solanaLoaded){
+					solanaDetection()
+					success(false)
+				}
+			}, 3000)
+			solanaDetection()
+		})
+	}
+
+	const enable = function () {
+		return new Promise((success, reject) => {
+			solana.connect().then(response=> {
+				publicKey = response.publicKey.toString()
+				success(true)
+			}).catch(error=> {
+				reject(exceptionHandler('solana-web3js', error, '', ERRORS.WEB3_ERROR))
+			})
+		})
+	}
+
+	const getAddress = function () {
+		return new Promise((success, reject) => {
+			if(publicKey === undefined) {
+				return reject(exceptionHandler('solana-web3js', 'NO PUBLIC ADDRESS', '', ERRORS.WEB3_ERROR))
+			}
+			return success(publicKey)
+		})
+	}
+
+	const getSignature = function (address, nonce, message) {
+		return new Promise((success, reject) => {
+			const encodedMessage = new TextEncoder().encode(message + nonce)
+			solana.signMessage(encodedMessage, 'utf8').then(signedMessage => {
+				const signature = ByteBase64Converter().bytesToBase64(signedMessage.signature)
+				success(signature)
+			}).catch(error => {
+				let errorCode = ERRORS.WEB3_ERROR
+				if (error.code === 4001) {
+					errorCode = ERRORS.SIGNATURE_REJECTED
+				}
+				reject(exceptionHandler('web3js', error.message, '', errorCode))
+			})
+		})
+	}
+
+	return {
+		isSupported,
+		enable,
+		getAddress,
+		getSignature,
+		ERRORS,
+	}
+}
+
+export const CryptoIntegration = function () {
+	const ERRORS = {
+		API_KEY_MISSING: 1,
+		ACCOUNT_NOT_FOUND: 2,
+		CONNECTION_REJECTED: 3,
+		SIGNATURE_REJECTED: 4,
+		SIGNATURE_MISMATCHED: 5,
+		NOT_AUTHENTICATED:6,
+		WEB3_ERROR: 9,
+		SERVER_ERROR: 10,
+		METHOD_NOT_SUPPORTED_BY_BLOCKCHAIN: 11,
+	}
+
+	const BLOCKCHAINS = [
+		'ethereum',
+		'solana'
+	]
+
+	const availableWallets = []
+	const supportedWallets = [
+		{
+			identifier: BLOCKCHAINS[0],
+			wrapper: EthereumWrapper(exception, ERRORS),
+		},
+		{
+			identifier: BLOCKCHAINS[1],
+			wrapper: SolanaWrapper(exception, ERRORS),
+		}
+	]
+
+	let selectedBlockchain
+	let walletWrapper
+
+	const getWalletWrapperByIdentifier = function (identifier) {
+		return supportedWallets.filter(wallet => wallet.identifier === identifier)[0]
+	}
+
+	const generateOnSupportedMethod = function (identifier) {
+		return function (isSupported) {
+			if (isSupported) {
+				const confirmedWallet = getWalletWrapperByIdentifier(identifier)
+				availableWallets.push(confirmedWallet)
+				const event = new CustomEvent('ttf.crypto.new-wallet', { detail: { identifier } })
+				window.dispatchEvent(event)
+			}
+		}
+	}
+
+	const checkAvailableWallets = function () {
+		for (let i = 0; i < supportedWallets.length; i++) {
+			const { wrapper } = supportedWallets[i]
+			const { identifier } = supportedWallets[i]
+			wrapper.isSupported().then(generateOnSupportedMethod(identifier))
+		}
+	}
+
+	const setBlockchain = function (blockchain) {
+		walletWrapper = getWalletWrapperByIdentifier(blockchain).wrapper
+		selectedBlockchain = blockchain
+	}
+
+	function exception(source, message, stacktrace, errorCode) {
+		return {
+			source,
+			message,
+			stacktrace,
+			errorCode
+		}
+	}
+
+	const getAuthenticatedUserAddress = function () {
+		return new Promise(async (success, reject) => {
+			try {
+				const response = await cryptoAccount(selectedBlockchain)
+				success({
+					address: _get(response, 'data.data.crypto_address'),
+					nonce: _get(response, 'data.data.eth_nonce')
+				})
+			} catch(error) {
+				let message = _get(error, 'response.data.message')
+				const statusCode = _get(error, 'response.status')
+				if (!message) {
+					message = _get(error, 'response.statusText')
+				}
+				let errorCode = ERRORS.SERVER_ERROR
+				if (statusCode === 404) {
+					errorCode = ERRORS.ACCOUNT_NOT_FOUND
+				} else if (statusCode === 401) {
+					errorCode = ERRORS.NOT_AUTHENTICATED
+				}
+				reject(exception('backend', message, '', errorCode))
+			}
+		})
+	}
+
+	const getNonceFromAddress = function (address) {
+		return new Promise(async (success, reject) => {
+			try {
+				const response = await cryptoAddress(selectedBlockchain, address)
+				const nonce = _get(response, 'data.data.eth_nonce')
+				success(nonce)
+			} catch(error) {
+				let message = _get(error, 'response.data.message')
+				const statusCode = _get(error, 'response.status')
+				if (!message) {
+					message = _get(error, 'response.statusText')
+				}
+				let errorCode = ERRORS.SERVER_ERROR
+				if (statusCode === 404) {
+					errorCode = ERRORS.ACCOUNT_NOT_FOUND
+				}
+				reject(exception('backend', message, '', errorCode))
+			}
+		})
+	}
+
+	const connectAddress = function (address, signature) {
+		return new Promise(async (success, reject) => {
+			try {
+				await cryptoConnect(selectedBlockchain, address, signature)
+				success()
+			} catch(error) {
+				let message = _get(error, 'response.data.message')
+				const statusCode = _get(error, 'response.status')
+				if (!message) {
+					message = _get(error, 'response.statusText')
+				}
+				let errorCode = ERRORS.SERVER_ERROR
+				if (statusCode === 404) {
+					errorCode = ERRORS.ACCOUNT_NOT_FOUND
+				} else if (statusCode === 422) {
+					errorCode = ERRORS.SIGNATURE_MISMATCHED
+				}
+				reject(exception('backend', message, '', errorCode))
+			}
+		})
+	}
+
+	const authAddress = function (address, signature) {
+		return new Promise(async (success, reject) => {
+			try {
+				await authorizeWithWallet(address, signature, selectedBlockchain)
+				success()
+			} catch (error) {
+				let message = _get(error, 'response.data.message')
+				const statusCode = _get(error, 'response.status')
+				if (!message) {
+					message = _get(error, 'response.statusText')
+				}
+				let errorCode = ERRORS.SERVER_ERROR
+				if (statusCode === 404) {
+					errorCode = ERRORS.ACCOUNT_NOT_FOUND
+				} else if (statusCode === 422) {
+					errorCode = ERRORS.SIGNATURE_MISMATCHED
+				}
+				reject(exception('backend', message, '', errorCode))
+			}
+		})
+	}
+
+	const isSupported = function () {
+		return walletWrapper.isSupported()
+	}
+
+	const enable = function () {
+		return walletWrapper.enable()
+	}
+
+	const getAddress = function () {
+		return walletWrapper.getAddress()
+	}
+
+	const getSignature = function (address, nonce, message) {
+		return walletWrapper.getSignature(address, nonce, message)
+	}
+
+	const getA0k1verseNFTs = function (address, ticketHash, amount) {
+		if (walletWrapper.getA0k1verseNFTs instanceof Function) {
+			return walletWrapper.getA0k1verseNFTs(address, ticketHash, amount)
+		}
+		return new Promise((success, reject) =>
+			reject(exception('Core', 'Method not supported by ' + selectedBlockchain, '', ERRORS.METHOD_NOT_SUPPORTED_BY_BLOCKCHAIN))
+		)
+	}
+
+	const hasAccountChanged = function () {
+		if (walletWrapper.hasAccountChanged instanceof Function) {
+			return walletWrapper.hasAccountChanged()
+		}
+		return new Promise((success, reject) =>
+			reject(exception('Core', 'Method not supported by ' + selectedBlockchain, '', ERRORS.METHOD_NOT_SUPPORTED_BY_BLOCKCHAIN))
+		)
+	}
+
+	checkAvailableWallets()
+	return {
+		isSupported,
+		enable,
+		getAuthenticatedUserAddress,
+		getAddress,
+		getNonceFromAddress,
+		getSignature,
+		authAddress,
+		connectAddress,
+		setBlockchain,
+		getA0k1verseNFTs,
+		hasAccountChanged,
+		ERRORS,
+	}
+}