github/self
1
1
Fork 0
mirror of https://github.com/selfxyz/self.git synced 2026-04-05 03:00:53 -04:00
Code Issues Packages Projects Releases Wiki Activity

Improve logs (#227)

Browse Source
This commit is contained in:
turnoffthiscomputer
2025-02-25 05:35:04 +01:00
committed by GitHub
parent 8e05820b2c
commit 0aff8628fc
4 changed files with 127 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
app/src/screens/Onboarding/LoadingScreen.tsx
View File

@@ -10,6 +10,7 @@ import successAnimation from '../../assets/animations/loading/success.json';
import useHapticNavigation from '../../hooks/useHapticNavigation';
import { usePassport } from '../../stores/passportDataProvider';
import { ProofStatusEnum, useProofInfo } from '../../stores/proofProvider';
import analytics from '../../utils/analytics';
import {
checkPassportSupported,
isPassportNullified,
@@ -17,6 +18,8 @@ import {
registerPassport,
} from '../../utils/proving/payload';
const { trackEvent } = analytics();
type LoadingScreenProps = StaticScreenProps<{}>;
const LoadingScreen: React.FC<LoadingScreenProps> = ({}) => {
@@ -72,7 +75,11 @@ const LoadingScreen: React.FC<LoadingScreenProps> = ({}) => {
}
const { passportData, secret } = passportDataAndSecret.data;
const isSupported = checkPassportSupported(passportData);
if (!isSupported) {
if (isSupported.status !== 'passport_supported') {
trackEvent('Passport not supported', {
reason: isSupported.status,
details: isSupported.details,
});
goToUnsupportedScreen();
console.log('Passport not supported');
clearPassportData();

25
app/src/screens/Onboarding/PassportCameraScreen.tsx
View File

@@ -1,4 +1,4 @@
import React, { useCallback } from 'react';
import React, { useCallback, useRef } from 'react';
import { Platform, StyleSheet } from 'react-native';
import { useIsFocused, useNavigation } from '@react-navigation/native';
@@ -32,16 +32,33 @@ const PassportCameraScreen: React.FC<PassportNFCScanScreen> = ({}) => {
const isFocused = useIsFocused();
const store = useUserStore();
// Add a ref to track when the camera screen is mounted
const scanStartTimeRef = useRef(Date.now());
const onPassportRead = useCallback<PassportCameraProps['onPassportRead']>(
(error, result) => {
// Calculate scan duration in seconds with exactly 2 decimal places
const scanDurationSeconds = (
(Date.now() - scanStartTimeRef.current) /
1000
).toFixed(2);
if (error) {
console.error(error);
trackEvent('Passport Camera Scan Failed', {
error: error.message || 'Unknown error',
duration_seconds: parseFloat(scanDurationSeconds),
});
//TODO: Add error handling here
return;
}
if (!result) {
console.error('No result from passport scan');
trackEvent('Passport Camera Scan Failed', {
error: 'No result from scan',
duration_seconds: parseFloat(scanDurationSeconds),
});
return;
}
@@ -63,6 +80,7 @@ const PassportCameraScreen: React.FC<PassportNFCScanScreen> = ({}) => {
passportNumberLength: passportNumber.length,
dateOfBirthLength: formattedDateOfBirth.length,
dateOfExpiryLength: formattedDateOfExpiry.length,
duration_seconds: parseFloat(scanDurationSeconds),
});
navigation.navigate('PassportCameraTrouble');
return;
@@ -78,6 +96,11 @@ const PassportCameraScreen: React.FC<PassportNFCScanScreen> = ({}) => {
dateOfBirth: formattedDateOfBirth,
dateOfExpiry: formattedDateOfExpiry,
});
trackEvent('Passport Camera Scan Successful', {
duration_seconds: parseFloat(scanDurationSeconds),
});
navigation.navigate('PassportNFCScan');
},
[store, navigation],

109
app/src/screens/Onboarding/PassportNFCScanScreen.tsx
View File

@@ -79,19 +79,32 @@ const PassportNFCScanScreen: React.FC<PassportNFCScanScreenProps> = ({}) => {
if (isNfcEnabled) {
setIsNfcSheetOpen(true);
// Add timestamp when scan starts
const scanStartTime = Date.now();
try {
const scanResponse = await scan({
passportNumber,
dateOfBirth,
dateOfExpiry,
});
console.log('NFC Scan Successful');
trackEvent('NFC Scan Successful');
const scanDurationSeconds = (
(Date.now() - scanStartTime) /
1000
).toFixed(2);
console.log(
'NFC Scan Successful - Duration:',
scanDurationSeconds,
'seconds',
);
trackEvent('NFC Scan Successful', {
duration_seconds: parseFloat(scanDurationSeconds),
});
let passportData: PassportData | null = null;
let parsedPassportData: PassportData | null = null;
try {
const passportData = parseScanResponse(scanResponse);
parsedPassportData = initPassportDataParsing(passportData);
passportData = parseScanResponse(scanResponse);
} catch (e: any) {
console.error('Parsing NFC Response Unsuccessful');
trackEvent('Parsing NFC Response Unsuccessful', {
@@ -99,44 +112,56 @@ const PassportNFCScanScreen: React.FC<PassportNFCScanScreenProps> = ({}) => {
});
return;
}
await storePassportData(parsedPassportData);
const passportMetadata = parsedPassportData.passportMetadata!;
trackEvent('Passport Parsed', {
success: true,
data_groups: passportMetadata.dataGroups,
dg1_size: passportMetadata.dg1Size,
dg1_hash_size: passportMetadata.dg1HashSize,
dg1_hash_function: passportMetadata.dg1HashFunction,
dg1_hash_offset: passportMetadata.dg1HashOffset,
dg_padding_bytes: passportMetadata.dgPaddingBytes,
e_content_size: passportMetadata.eContentSize,
e_content_hash_function: passportMetadata.eContentHashFunction,
e_content_hash_offset: passportMetadata.eContentHashOffset,
signed_attr_size: passportMetadata.signedAttrSize,
signed_attr_hash_function: passportMetadata.signedAttrHashFunction,
signature_algorithm: passportMetadata.signatureAlgorithm,
salt_length: passportMetadata.saltLength,
curve_or_exponent: passportMetadata.curveOrExponent,
signature_algorithm_bits: passportMetadata.signatureAlgorithmBits,
country_code: passportMetadata.countryCode,
csca_found: passportMetadata.cscaFound,
csca_hash_function: passportMetadata.cscaHashFunction,
csca_signature_algorithm: passportMetadata.cscaSignatureAlgorithm,
csca_salt_length: passportMetadata.cscaSaltLength,
csca_curve_or_exponent: passportMetadata.cscaCurveOrExponent,
csca_signature_algorithm_bits:
passportMetadata.cscaSignatureAlgorithmBits,
dsc: passportMetadata.dsc,
});
// Feels better somehow
await new Promise(resolve => setTimeout(resolve, 1000));
navigation.navigate('ConfirmBelongingScreen');
try {
parsedPassportData = initPassportDataParsing(passportData);
const passportMetadata = parsedPassportData.passportMetadata!;
trackEvent('Passport Parsed', {
success: true,
data_groups: passportMetadata.dataGroups,
dg1_size: passportMetadata.dg1Size,
dg1_hash_size: passportMetadata.dg1HashSize,
dg1_hash_function: passportMetadata.dg1HashFunction,
dg1_hash_offset: passportMetadata.dg1HashOffset,
dg_padding_bytes: passportMetadata.dgPaddingBytes,
e_content_size: passportMetadata.eContentSize,
e_content_hash_function: passportMetadata.eContentHashFunction,
e_content_hash_offset: passportMetadata.eContentHashOffset,
signed_attr_size: passportMetadata.signedAttrSize,
signed_attr_hash_function: passportMetadata.signedAttrHashFunction,
signature_algorithm: passportMetadata.signatureAlgorithm,
salt_length: passportMetadata.saltLength,
curve_or_exponent: passportMetadata.curveOrExponent,
signature_algorithm_bits: passportMetadata.signatureAlgorithmBits,
country_code: passportMetadata.countryCode,
csca_found: passportMetadata.cscaFound,
csca_hash_function: passportMetadata.cscaHashFunction,
csca_signature_algorithm: passportMetadata.cscaSignatureAlgorithm,
csca_salt_length: passportMetadata.cscaSaltLength,
csca_curve_or_exponent: passportMetadata.cscaCurveOrExponent,
csca_signature_algorithm_bits:
passportMetadata.cscaSignatureAlgorithmBits,
dsc: passportMetadata.dsc,
});
await storePassportData(parsedPassportData);
// Feels better somehow
await new Promise(resolve => setTimeout(resolve, 1000));
navigation.navigate('ConfirmBelongingScreen');
} catch (e: any) {
console.error('Passport Parsed Failed:', e);
trackEvent('Passport Parsed Failed', {
error: e.message,
});
return;
}
} catch (e: any) {
const scanDurationSeconds = (
(Date.now() - scanStartTime) /
1000
).toFixed(2);
console.error('NFC Scan Unsuccessful:', e);
trackEvent('NFC Scan Unsuccessful', {
error: e.message,
duration_seconds: parseFloat(scanDurationSeconds),
});
if (e.message.includes('InvalidMRZKey')) {
@@ -152,6 +177,14 @@ const PassportNFCScanScreen: React.FC<PassportNFCScanScreenProps> = ({}) => {
} else if (e.message.includes('UnexpectedError')) {
// iOS
// Timeout reached, do nothing
} else if (
e.message.includes('Error: Lost connection to chip on card')
) {
// android
navigation.navigate('PassportNFCTrouble');
} else if (e.message.includes('Could not tranceive APDU')) {
// android
navigation.navigate('PassportNFCTrouble');
} else {
// TODO: Handle other error types
}

36
app/src/utils/proving/payload.ts
View File

@@ -54,34 +54,46 @@ async function generateTeeInputsRegister(
return { inputs, circuitName };
}
export function checkPassportSupported(passportData: PassportData) {
export type PassportSupportStatus =
| 'passport_metadata_missing'
| 'csca_not_found'
| 'registration_circuit_not_supported'
| 'dsc_circuit_not_supported'
| 'passport_supported';
export function checkPassportSupported(passportData: PassportData): {
status: PassportSupportStatus;
details: string;
} {
const passportMetadata = passportData.passportMetadata;
if (!passportMetadata) {
console.log('Passport metadata is null');
return false;
return { status: 'passport_metadata_missing', details: passportData.dsc };
}
if (!passportMetadata.cscaFound) {
console.log('CSCA not found');
return false;
return { status: 'csca_not_found', details: passportData.dsc };
}
const circuitNameRegister = getCircuitNameFromPassportData(
passportData,
'register',
);
console.log('circuitNameRegister', circuitNameRegister);
if (
!circuitNameRegister ||
!DEPLOYED_CIRCUITS_REGISTER.includes(circuitNameRegister)
) {
console.log('Circuit not supported:', circuitNameRegister);
return false;
return {
status: 'registration_circuit_not_supported',
details: circuitNameRegister,
};
}
const circuitNameDsc = getCircuitNameFromPassportData(passportData, 'dsc');
if (!circuitNameDsc || !DEPLOYED_CIRCUITS_DSC.includes(circuitNameDsc)) {
console.log('DSC circuit not supported:', circuitNameDsc);
return false;
return { status: 'dsc_circuit_not_supported', details: circuitNameDsc };
}
console.log('Passport supported');
return true;
return { status: 'passport_supported', details: 'null' };
}
export async function sendRegisterPayload(
@@ -159,11 +171,11 @@ export async function sendDscPayload(
if (!passportData) {
return false;
}
const isSupported = checkPassportSupported(passportData);
if (!isSupported) {
console.log('Passport not supported');
return false;
}
// const isSupported = checkPassportSupported(passportData);
// if (!isSupported) {
// console.log('Passport not supported');
// return false;
// }
const { inputs, circuitName } = await generateTeeInputsDsc(passportData);
console.log('circuitName', circuitName);
const dscStatus = await sendPayload(