@beclab/olaresid 0.1.4 → 0.1.6

package/src/business/index.ts

@@ -4,6 +4,12 @@ import { parseContractError } from '../utils/error-parser';
 import { TagContext } from './tag-context';
 import { TagTypeBuilder } from '../utils/tag-type-builder';
 import { normalizeToDomain } from '../utils/olares-id';
+import {
+	base64ToUint8Array,
+	uint8ArrayToHex,
+	hexToUint8Array,
+	uint8ArrayToBase64
+} from '../utils/crypto-utils';
 
 export interface TransactionResult<T = any> {
 	// Basic transaction information
@@ -48,7 +54,11 @@ export {
 	getDIDFromMnemonic,
 	generateDIDKeyData,
 	deriveDIDFromMnemonic,
-	getEd25519JwkFromMnemonic
+	getEd25519JwkFromMnemonic,
+	base64ToUint8Array,
+	uint8ArrayToHex,
+	hexToUint8Array,
+	uint8ArrayToBase64
 } from '../utils/crypto-utils';
 export type { RSAPublicKeyData, DIDKeyData } from '../utils/crypto-utils';
 
@@ -180,7 +190,7 @@ export class DomainContext {
 	 * ```typescript
 	 * // For parent domain "parent.com", register subdomain "child"
 	 * const parentDomain = olaresId.domain('parent.com');
-	 * const mnemonic = generateMnemonic(12);
+	 * const mnemonic = await generateMnemonic(12);
 	 *
 	 * const result = await parentDomain.registerSubdomain('child', mnemonic);
 	 * // This will register "child.parent.com"
@@ -266,7 +276,7 @@ export class DomainContext {
 	 *
 	 * @example
 	 * ```typescript
-	 * const mnemonic = generateMnemonic(12);
+	 * const mnemonic = await generateMnemonic(12);
 	 * const result = await domain.transfer(mnemonic);
 	 * if (result.success) {
 	 *   console.log('Domain transferred!');
@@ -846,18 +856,22 @@ export class DomainContext {
 			const { Keypair } = await import('@solana/web3.js');
 			const nacl = await import('tweetnacl');
 			const { decodeUTF8 } = await import('tweetnacl-util');
+			const { base58btc } = await import('multiformats/bases/base58');
 
 			// Parse Solana private key (support both base58 and base64)
 			let solanaWallet: any;
 			try {
 				// Try base58 first (most common format for Phantom)
-				const bs58 = await import('bs58');
-				const secretKey = bs58.default.decode(solanaPrivateKey);
+				// Solana uses plain base58, but multiformats requires 'z' prefix for multibase
+				const base58Key = solanaPrivateKey.startsWith('z')
+					? solanaPrivateKey
+					: 'z' + solanaPrivateKey;
+				const secretKey = base58btc.decode(base58Key);
 				solanaWallet = Keypair.fromSecretKey(secretKey);
 			} catch {
 				// Try base64
 				try {
-					const secretKey = Buffer.from(solanaPrivateKey, 'base64');
+					const secretKey = base64ToUint8Array(solanaPrivateKey);
 					solanaWallet = Keypair.fromSecretKey(secretKey);
 				} catch {
 					// Try as JSON array
@@ -868,9 +882,9 @@ export class DomainContext {
 				}
 			}
 
-			// Get Solana address as bytes32
+			// Get Solana address as bytes32 (cross-platform)
 			const solanaAddressBytes =
-				'0x' + solanaWallet.publicKey.toBuffer().toString('hex');
+				'0x' + uint8ArrayToHex(solanaWallet.publicKey.toBytes());
 
 			// Get current timestamp
 			const signAt = Math.floor(Date.now() / 1000) - 30 * 60; // 30 minutes ago
@@ -930,8 +944,8 @@ export class DomainContext {
 				decodeUTF8(solanaMsg),
 				solanaWallet.secretKey
 			);
-			const sigFromAuthAddrHex =
-				'0x' + Buffer.from(sigFromAuthAddr).toString('hex');
+			// Convert signature to hex (cross-platform)
+			const sigFromAuthAddrHex = '0x' + uint8ArrayToHex(sigFromAuthAddr);
 
 			// Call contract
 			const tx = await rootTagger.updateSolanaWallet(
@@ -979,18 +993,22 @@ export class DomainContext {
 		try {
 			// Import Solana libraries dynamically
 			const { Keypair } = await import('@solana/web3.js');
+			const { base58btc } = await import('multiformats/bases/base58');
 
 			// Parse Solana private key
 			let solanaWallet: any;
 			try {
 				// Try base58 first
-				const bs58 = await import('bs58');
-				const secretKey = bs58.default.decode(solanaPrivateKey);
+				// Solana uses plain base58, but multiformats requires 'z' prefix for multibase
+				const base58Key = solanaPrivateKey.startsWith('z')
+					? solanaPrivateKey
+					: 'z' + solanaPrivateKey;
+				const secretKey = base58btc.decode(base58Key);
 				solanaWallet = Keypair.fromSecretKey(secretKey);
 			} catch {
 				// Try base64
 				try {
-					const secretKey = Buffer.from(solanaPrivateKey, 'base64');
+					const secretKey = base64ToUint8Array(solanaPrivateKey);
 					solanaWallet = Keypair.fromSecretKey(secretKey);
 				} catch {
 					// Try as JSON array
@@ -1001,9 +1019,9 @@ export class DomainContext {
 				}
 			}
 
-			// Get Solana address as bytes32
+			// Get Solana address as bytes32 (cross-platform)
 			const solanaAddressBytes =
-				'0x' + solanaWallet.publicKey.toBuffer().toString('hex');
+				'0x' + uint8ArrayToHex(solanaWallet.publicKey.toBytes());
 
 			// Get current timestamp
 			const signAt = Math.floor(Date.now() / 1000) - 30 * 60; // 30 minutes ago
@@ -1104,11 +1122,8 @@ export class DomainContext {
 			// Extract addresses from the result and convert to base58
 			// Result is array of { algorithm, addr } where addr is bytes32
 			return result.map((item: any) => {
-				// Remove 0x prefix and convert hex to buffer
-				const hexStr = item.addr.startsWith('0x')
-					? item.addr.slice(2)
-					: item.addr;
-				const buffer = Buffer.from(hexStr, 'hex');
+				// Convert hex to Uint8Array (cross-platform)
+				const buffer = hexToUint8Array(item.addr);
 				// Convert to Solana public key and then to base58
 				return new PublicKey(buffer).toBase58();
 			});
@@ -1423,26 +1438,16 @@ export function bytes4ToIpv4(bytes4Hex: string): string {
  */
 export function pemToDer(pem: string): string {
 	// Remove PEM headers, footers, and whitespace
-	const base64 = pem
+	const base64Str = pem
 		.replace(/-----BEGIN.*?-----/g, '')
 		.replace(/-----END.*?-----/g, '')
 		.replace(/\s/g, '');
 
-	// Convert base64 to hex
-	let hexString: string;
-
-	// Check if running in Node.js or browser
-	if (typeof Buffer !== 'undefined') {
-		// Node.js environment
-		const derBuffer = Buffer.from(base64, 'base64');
-		hexString = derBuffer.toString('hex');
-	} else {
-		// Browser environment
-		const binaryString = atob(base64);
-		hexString = Array.from(binaryString, (char) =>
-			char.charCodeAt(0).toString(16).padStart(2, '0')
-		).join('');
-	}
+	// Convert base64 to Uint8Array using cross-platform method
+	const derBuffer = base64ToUint8Array(base64Str);
+
+	// Convert to hex string
+	const hexString = uint8ArrayToHex(derBuffer);
 
 	// Convert to hex string with 0x prefix
 	return '0x' + hexString;
@@ -1457,31 +1462,14 @@ export function derToPem(derHex: string): string {
 	// Remove '0x' prefix if present
 	const hexString = derHex.startsWith('0x') ? derHex.slice(2) : derHex;
 
-	// Convert hex to base64
-	let base64: string;
-
-	// Check if running in Node.js or browser
-	if (typeof Buffer !== 'undefined') {
-		// Node.js environment
-		const derBuffer = Buffer.from(hexString, 'hex');
-		base64 = derBuffer.toString('base64');
-	} else {
-		// Browser environment
-		// Convert hex string to byte array
-		const bytes = new Uint8Array(hexString.length / 2);
-		for (let i = 0; i < hexString.length; i += 2) {
-			bytes[i / 2] = parseInt(hexString.substr(i, 2), 16);
-		}
-		// Convert byte array to binary string
-		const binaryString = String.fromCharCode(...bytes);
-		// Convert to base64
-		base64 = btoa(binaryString);
-	}
+	// Convert hex to base64 using cross-platform methods
+	const bytes = hexToUint8Array(hexString);
+	const base64Str = uint8ArrayToBase64(bytes);
 
 	// Split base64 into 64-character lines for PEM format
 	const lines: string[] = [];
-	for (let i = 0; i < base64.length; i += 64) {
-		lines.push(base64.slice(i, i + 64));
+	for (let i = 0; i < base64Str.length; i += 64) {
+		lines.push(base64Str.slice(i, i + 64));
 	}
 
 	// Construct PEM format with headers and footers

package/src/cli.ts

@@ -1014,7 +1014,7 @@ async function registerSubdomain(
 				);
 				process.exit(1);
 			}
-			mnemonic = generateMnemonic(wordCount);
+			mnemonic = await generateMnemonic(wordCount);
 
 			// Save mnemonic to file
 			const mnemonicFile = './subdomain-mnemonic.txt';
@@ -1141,7 +1141,7 @@ async function transferDomain(
 				);
 				process.exit(1);
 			}
-			mnemonic = generateMnemonic(wordCount);
+			mnemonic = await generateMnemonic(wordCount);
 
 			// Save mnemonic to file
 			const mnemonicFile = './transfer-new-owner-mnemonic.txt';
@@ -1228,7 +1228,7 @@ async function cryptoGenerate(options: CliOptions): Promise<void> {
 			process.exit(1);
 		}
 
-		const mnemonic = generateMnemonic(wordCount);
+		const mnemonic = await generateMnemonic(wordCount);
 
 		// Save mnemonic to file
 		const outputFile = options.output || './mnemonic.txt';

package/src/index.ts

@@ -38,7 +38,12 @@ export {
 	getDIDFromMnemonic,
 	generateDIDKeyData,
 	deriveDIDFromMnemonic,
-	getEd25519JwkFromMnemonic
+	getEd25519JwkFromMnemonic,
+	// Cross-platform encoding utilities
+	base64ToUint8Array,
+	uint8ArrayToHex,
+	hexToUint8Array,
+	uint8ArrayToBase64
 } from './business';
 
 type Domain = PackageDomain.Domain;

package/src/utils/crypto-utils.ts

@@ -6,13 +6,13 @@
  * compatibility across the entire Olares ecosystem.
  */
 
-import * as bip39 from 'bip39';
 import * as varint from 'varint';
 import { base58btc } from 'multiformats/bases/base58';
 import { base64url } from 'multiformats/bases/base64';
 
 // Browser globals type declaration
 declare const window: any;
+declare const atob: (input: string) => string;
 declare const btoa: (input: string) => string;
 
 export interface RSAPublicKeyData {
@@ -26,6 +26,61 @@ export interface DIDKeyData {
 	mnemonic: string;
 }
 
+// ============================================================================
+// Cross-platform encoding utilities (Browser + Node.js compatible)
+// ============================================================================
+
+/**
+ * Convert base64 string to Uint8Array (cross-platform)
+ * Works in both browser and Node.js environments
+ * @param base64 base64 encoded string
+ * @returns Uint8Array
+ */
+export function base64ToUint8Array(base64: string): Uint8Array {
+	const binaryString = atob(base64);
+	const bytes = new Uint8Array(binaryString.length);
+	for (let i = 0; i < binaryString.length; i++) {
+		bytes[i] = binaryString.charCodeAt(i);
+	}
+	return bytes;
+}
+
+/**
+ * Convert Uint8Array to hex string (cross-platform)
+ * @param bytes Uint8Array to convert
+ * @returns hex string without '0x' prefix
+ */
+export function uint8ArrayToHex(bytes: Uint8Array): string {
+	return Array.from(bytes)
+		.map((b) => b.toString(16).padStart(2, '0'))
+		.join('');
+}
+
+/**
+ * Convert hex string to Uint8Array (cross-platform)
+ * @param hex hex string (with or without '0x' prefix)
+ * @returns Uint8Array
+ */
+export function hexToUint8Array(hex: string): Uint8Array {
+	const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+	const bytes = new Uint8Array(cleanHex.length / 2);
+	for (let i = 0; i < cleanHex.length; i += 2) {
+		bytes[i / 2] = parseInt(cleanHex.slice(i, i + 2), 16);
+	}
+	return bytes;
+}
+
+/**
+ * Convert Uint8Array to base64 string (cross-platform)
+ * Works in both browser and Node.js environments
+ * @param bytes Uint8Array to convert
+ * @returns base64 encoded string
+ */
+export function uint8ArrayToBase64(bytes: Uint8Array): string {
+	const binaryString = String.fromCharCode(...bytes);
+	return btoa(binaryString);
+}
+
 // ============================================================================
 // Trust Wallet Core Management
 // ============================================================================
@@ -37,6 +92,7 @@ let loadingPromise: Promise<any> | null = null;
 /**
  * Load Trust Wallet Core (lazy loading)
  * Works in both Node.js and browser environments
+ * Handles different module export formats (CommonJS vs ESM)
  */
 async function loadWalletCore(): Promise<any> {
 	// Return cached instance if already loaded
@@ -52,18 +108,33 @@ async function loadWalletCore(): Promise<any> {
 	// Start loading
 	loadingPromise = (async () => {
 		try {
-			// Check if running in browser or Node.js
-			if (
-				typeof window !== 'undefined' &&
-				typeof require === 'undefined'
+			// Dynamic import works in both Node.js ESM and browser ESM
+			const WalletCoreModule = await import('@trustwallet/wallet-core');
+
+			// Handle different export formats (CommonJS vs ESM)
+			let initWasmFunc: any;
+			if (WalletCoreModule.initWasm) {
+				// ESM named export
+				initWasmFunc = WalletCoreModule.initWasm;
+			} else if (
+				WalletCoreModule.default &&
+				(WalletCoreModule.default as any).initWasm
 			) {
-				// Browser environment with ES modules
-				const { initWasm } = await import('@trustwallet/wallet-core');
-				walletCore = await initWasm();
+				// ESM default export with initWasm
+				initWasmFunc = (WalletCoreModule.default as any).initWasm;
+			} else if (WalletCoreModule.default) {
+				// Default export is the function itself
+				initWasmFunc = WalletCoreModule.default;
+			} else {
+				// Module itself is the function
+				initWasmFunc = WalletCoreModule as any;
+			}
+
+			// Call the init function
+			if (typeof initWasmFunc === 'function') {
+				walletCore = await initWasmFunc();
 			} else {
-				// Node.js environment
-				const { initWasm } = require('@trustwallet/wallet-core');
-				walletCore = await initWasm();
+				throw new Error('initWasm is not a function');
 			}
 
 			walletCoreLoaded = true;
@@ -84,23 +155,38 @@ async function loadWalletCore(): Promise<any> {
 // multicodec code for Ed25519 keys (0xed)
 const ED25519_CODEC_ID = varint.encode(parseInt('0xed', 16));
 
+/**
+ * Simple mnemonic validation (checks word count)
+ * @param mnemonic BIP39 mnemonic phrase
+ * @returns true if mnemonic has valid word count (12, 15, 18, 21, or 24 words)
+ */
+function validateMnemonic(mnemonic: string): boolean {
+	const words = mnemonic.trim().split(/\s+/);
+	const validWordCounts = [12, 15, 18, 21, 24];
+	return validWordCounts.includes(words.length);
+}
+
 // ============================================================================
 // Mnemonic and Key Derivation Functions
 // ============================================================================
 
 /**
- * Generate a random BIP39 mnemonic phrase
+ * Generate a random BIP39 mnemonic phrase using Trust Wallet Core
+ * Works in both Node.js and browser environments
+ *
  * @param wordCount Number of words (12, 15, 18, 21, or 24), default is 12
- * @returns A mnemonic phrase string
+ * @returns A promise that resolves to a mnemonic phrase string
  *
  * @example
  * ```typescript
- * const mnemonic = generateMnemonic(12);
+ * const mnemonic = await generateMnemonic(12);
  * console.log(mnemonic);
  * // Output: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
  * ```
  */
-export function generateMnemonic(wordCount: number = 12): string {
+export async function generateMnemonic(
+	wordCount: number = 12
+): Promise<string> {
 	// Convert word count to entropy bits
 	// 12 words = 128 bits, 15 words = 160 bits, etc.
 	const strengthMap: Record<number, number> = {
@@ -118,7 +204,14 @@ export function generateMnemonic(wordCount: number = 12): string {
 		);
 	}
 
-	return bip39.generateMnemonic(strength);
+	// Ensure Wallet Core is loaded
+	const core = await loadWalletCore();
+	const { HDWallet } = core;
+
+	const wallet = HDWallet.create(strength, '');
+	const mnemonic = wallet.mnemonic();
+
+	return mnemonic;
 }
 
 /**
@@ -138,8 +231,10 @@ export async function getEthereumAddressFromMnemonic(
 	mnemonic: string
 ): Promise<string> {
 	// Validate mnemonic
-	if (!bip39.validateMnemonic(mnemonic)) {
-		throw new Error('Invalid mnemonic phrase');
+	if (!validateMnemonic(mnemonic)) {
+		throw new Error(
+			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
+		);
 	}
 
 	const core = await loadWalletCore();
@@ -167,8 +262,10 @@ export async function getEVMPrivateKeyFromMnemonic(
 	mnemonic: string
 ): Promise<string> {
 	// Validate mnemonic
-	if (!bip39.validateMnemonic(mnemonic)) {
-		throw new Error('Invalid mnemonic phrase');
+	if (!validateMnemonic(mnemonic)) {
+		throw new Error(
+			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
+		);
 	}
 
 	const core = await loadWalletCore();
@@ -179,9 +276,9 @@ export async function getEVMPrivateKeyFromMnemonic(
 	// Get private key for Ethereum
 	const privateKeyData = wallet.getKeyForCoin(CoinType.ethereum);
 
-	// Convert to hex string with 0x prefix
-	const privateKeyHex =
-		'0x' + Buffer.from(privateKeyData.data()).toString('hex');
+	// Convert to hex string with 0x prefix (cross-platform)
+	const privateKeyBytes = new Uint8Array(privateKeyData.data());
+	const privateKeyHex = '0x' + uint8ArrayToHex(privateKeyBytes);
 
 	return privateKeyHex;
 }
@@ -230,8 +327,10 @@ async function getID(mnemonic: string): Promise<string> {
  */
 export async function getDIDFromMnemonic(mnemonic: string): Promise<string> {
 	// Validate mnemonic
-	if (!bip39.validateMnemonic(mnemonic)) {
-		throw new Error('Invalid mnemonic phrase');
+	if (!validateMnemonic(mnemonic)) {
+		throw new Error(
+			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
+		);
 	}
 
 	const id = await getID(mnemonic);
@@ -278,8 +377,10 @@ export async function getEd25519JwkFromMnemonic(mnemonic: string): Promise<{
 	privateJwk: any;
 }> {
 	// Validate mnemonic
-	if (!bip39.validateMnemonic(mnemonic)) {
-		throw new Error('Invalid mnemonic phrase');
+	if (!validateMnemonic(mnemonic)) {
+		throw new Error(
+			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
+		);
 	}
 
 	const core = await loadWalletCore();
@@ -300,7 +401,6 @@ export async function getEd25519JwkFromMnemonic(mnemonic: string): Promise<{
 	idBytes.set(publicKeyBytes, ED25519_CODEC_ID.length);
 	const id = base58btc.encode(idBytes);
 	const did = `did:key:${id}`;
-	const keyId = `${did}#${id}`;
 
 	// Base64url encode the keys
 	const x = base64url.baseEncode(publicKeyBytes);
@@ -312,7 +412,7 @@ export async function getEd25519JwkFromMnemonic(mnemonic: string): Promise<{
 		crv: 'Ed25519', // Curve: Ed25519
 		alg: 'EdDSA', // Algorithm: EdDSA
 		use: 'sig', // Use: signature
-		kid: keyId, // Key ID
+		kid: did, // DID
 		x: x // Public key parameter
 	};
 
@@ -343,8 +443,10 @@ export async function deriveDIDFromMnemonic(mnemonic: string): Promise<{
 	did: string;
 }> {
 	// Validate mnemonic once upfront
-	if (!bip39.validateMnemonic(mnemonic)) {
-		throw new Error('Invalid mnemonic phrase');
+	if (!validateMnemonic(mnemonic)) {
+		throw new Error(
+			'Invalid mnemonic phrase: must have 12, 15, 18, 21, or 24 words'
+		);
 	}
 
 	// Derive both in parallel for better performance
@@ -373,7 +475,7 @@ export async function deriveDIDFromMnemonic(mnemonic: string): Promise<{
 export async function generateDIDKeyData(
 	wordCount: number = 12
 ): Promise<DIDKeyData> {
-	const mnemonic = generateMnemonic(wordCount);
+	const mnemonic = await generateMnemonic(wordCount);
 	const { owner, did } = await deriveDIDFromMnemonic(mnemonic);
 
 	return {

package/examples/quasar-demo/.eslintrc.js

@@ -1,23 +0,0 @@
-module.exports = {
-	root: true,
-	parserOptions: {
-		parser: '@typescript-eslint/parser',
-		ecmaVersion: 2021
-	},
-	env: {
-		browser: true,
-		es2021: true,
-		node: true
-	},
-	extends: [
-		'plugin:vue/vue3-essential',
-		'eslint:recommended',
-		'@vue/typescript/recommended',
-		'prettier'
-	],
-	plugins: ['vue', '@typescript-eslint'],
-	rules: {
-		'@typescript-eslint/no-explicit-any': 'off',
-		'@typescript-eslint/no-unused-vars': 'warn'
-	}
-};

package/examples/quasar-demo/.quasar/app.js

@@ -1,43 +0,0 @@
-/* eslint-disable */
-/**
- * THIS FILE IS GENERATED AUTOMATICALLY.
- * DO NOT EDIT.
- *
- * You are probably looking on adding startup/initialization code.
- * Use "quasar new boot <name>" and add it there.
- * One boot file per concern. Then reference the file(s) in quasar.config.js > boot:
- * boot: ['file', ...] // do not add ".js" extension to it.
- *
- * Boot files are your "main.js"
- **/
-
-import { Quasar } from 'quasar';
-import { markRaw } from 'vue';
-import RootComponent from 'app/src/App.vue';
-
-import createRouter from 'app/src/router/index';
-
-export default async function (createAppFn, quasarUserOptions) {
-	// Create the app instance.
-	// Here we inject into it the Quasar UI, the router & possibly the store.
-	const app = createAppFn(RootComponent);
-
-	app.config.performance = true;
-
-	app.use(Quasar, quasarUserOptions);
-
-	const router = markRaw(
-		typeof createRouter === 'function'
-			? await createRouter({})
-			: createRouter
-	);
-
-	// Expose the app, the router and the store.
-	// Note that we are not mounting the app here, since bootstrapping will be
-	// different depending on whether we are in a browser or on the server.
-	return {
-		app,
-
-		router
-	};
-}

package/examples/quasar-demo/.quasar/client-entry.js

@@ -1,38 +0,0 @@
-/* eslint-disable */
-/**
- * THIS FILE IS GENERATED AUTOMATICALLY.
- * DO NOT EDIT.
- *
- * You are probably looking on adding startup/initialization code.
- * Use "quasar new boot <name>" and add it there.
- * One boot file per concern. Then reference the file(s) in quasar.config.js > boot:
- * boot: ['file', ...] // do not add ".js" extension to it.
- *
- * Boot files are your "main.js"
- **/
-
-import { createApp } from 'vue';
-
-import '@quasar/extras/roboto-font/roboto-font.css';
-
-import '@quasar/extras/material-icons/material-icons.css';
-
-// We load Quasar stylesheet file
-import 'quasar/dist/quasar.css';
-
-import 'src/css/app.scss';
-
-import createQuasarApp from './app.js';
-import quasarUserOptions from './quasar-user-options.js';
-
-console.info('[Quasar] Running SPA.');
-
-const publicPath = `/`;
-
-async function start({ app, router }) {
-	app.use(router);
-
-	app.mount('#q-app');
-}
-
-createQuasarApp(createApp, quasarUserOptions).then(start);