solana-age-verify-sdk 2.0.0-beta.7 → 2.0.0-beta.9

package/dist/verify.js

@@ -664,88 +664,128 @@ export async function verifyHost18Plus(options) {
             }
             try {
                 const fromPubkey = options.wallet.publicKey;
-                // ONLY compute facehash right before signing - ensures it's tied to wallet consent
-                if (embedding.length > 0) {
-                    facehash = await computeFaceHash(options.walletPubkeyBase58, salt, embedding);
+                // Debug checks exposed to UI via error message
+                try {
+                    new PublicKey(fromPubkey);
+                }
+                catch (e) {
+                    throw new Error(`Invalid Wallet Public Key: ${e.message}`);
+                }
+                try {
+                    new PublicKey(platformPubKey);
+                }
+                catch (e) {
+                    throw new Error(`Invalid Treasury Public Key (Check VITE_TREASURY_ADDRESS): ${e.message}`);
+                }
+                // Step 1: FaceHash
+                try {
+                    if (embedding.length > 0) {
+                        facehash = await computeFaceHash(options.walletPubkeyBase58, salt, embedding);
+                    }
+                }
+                catch (e) {
+                    throw new Error(`FaceHash Computation Failed: ${e.message}`);
                 }
-                console.log('[DEBUG] Fee Payment Init', {
-                    fromPubkey: fromPubkey?.toString(),
-                    platformPubKey: platformPubKey?.toString(),
-                    protocolFeeSol
-                });
                 const transaction = new Transaction();
-                // 0. Prioritization Fees & Compute Limits (Crucial for Mainnet reliability)
-                transaction.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 50000 }), ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 100000 }) // Priority fee
-                );
-                // 1. Protocol Fee Transfer
-                transaction.add(SystemProgram.transfer({
-                    fromPubkey,
-                    toPubkey: platformPubKey,
-                    lamports: protocolFeeSol * LAMPORTS_PER_SOL,
-                }));
-                // 2. Add Verification Memo (signed by both User and Platform)
+                transaction.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 50000 }), ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 100000 }));
+                // Step 2: Protocol Fee Instruction
+                try {
+                    transaction.add(SystemProgram.transfer({
+                        fromPubkey,
+                        toPubkey: platformPubKey,
+                        lamports: protocolFeeSol * LAMPORTS_PER_SOL,
+                    }));
+                }
+                catch (e) {
+                    throw new Error(`Fee Transfer Instruction Failed: ${e.message}`);
+                }
                 const statusStr = isOver18 ? 'OVER18' : (isFinalStrike ? 'FINAL_FAILURE' : 'UNDER18');
                 const memoText = `Solana-Age-Registry | ${statusStr} | HASH: ${facehash} | ${verifiedAt}`;
-                transaction.add(new TransactionInstruction({
-                    keys: [
-                        { pubkey: fromPubkey, isSigner: true, isWritable: false },
-                        { pubkey: platformPubKey, isSigner: true, isWritable: false } // Required platform signature
-                    ],
-                    programId: getMemoProgramId(),
-                    data: new TextEncoder().encode(memoText),
-                }));
+                // Step 3: Memo Instruction
+                try {
+                    transaction.add(new TransactionInstruction({
+                        keys: [
+                            { pubkey: fromPubkey, isSigner: true, isWritable: false },
+                            { pubkey: platformPubKey, isSigner: true, isWritable: false }
+                        ],
+                        programId: getMemoProgramId(),
+                        data: new TextEncoder().encode(memoText),
+                    }));
+                }
+                catch (e) {
+                    throw new Error(`Memo Instruction Failed: ${e.message}`);
+                }
                 const { blockhash } = await options.connection.getLatestBlockhash();
                 transaction.recentBlockhash = blockhash;
                 transaction.feePayer = fromPubkey;
-                // 3. SECURE SERVER-SIDE SIGNING
-                // We send the transaction to the Vercel API to get the Platform's signature
-                const signResponse = await fetch('/api/sign-verification', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        serializedTx: transaction.serialize({
-                            requireAllSignatures: false,
-                            verifySignatures: false
-                        }).toString('base64')
-                    })
-                });
-                if (!signResponse.ok) {
-                    const signError = await signResponse.json();
-                    console.error('[DEBUG] Sign API Error:', signError);
-                    throw new Error(signError.message || 'Platform signing failed');
+                // Step 4: Serialization
+                let serializedTxBase64;
+                try {
+                    serializedTxBase64 = transaction.serialize({
+                        requireAllSignatures: false,
+                        verifySignatures: false
+                    }).toString('base64');
                 }
-                const { transaction: platformSignedTxBase64 } = await signResponse.json();
-                const platformSignedTxData = atob(platformSignedTxBase64);
-                const platformSignedTxUint8 = new Uint8Array(platformSignedTxData.length);
-                for (let i = 0; i < platformSignedTxData.length; i++) {
-                    platformSignedTxUint8[i] = platformSignedTxData.charCodeAt(i);
+                catch (e) {
+                    throw new Error(`Transaction Serialization Failed: ${e.message}`);
+                }
+                // Step 5: Server Signing
+                let platformSignedTx;
+                try {
+                    const signResponse = await fetch('/api/sign-verification', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ serializedTx: serializedTxBase64 })
+                    });
+                    if (!signResponse.ok) {
+                        const signError = await signResponse.json();
+                        throw new Error(`Server API Error: ${signError.message || signError.error}`);
+                    }
+                    const { transaction: txBase64 } = await signResponse.json();
+                    const txData = atob(txBase64);
+                    const txUint8 = new Uint8Array(txData.length);
+                    for (let i = 0; i < txData.length; i++) {
+                        txUint8[i] = txData.charCodeAt(i);
+                    }
+                    platformSignedTx = Transaction.from(txUint8);
+                }
+                catch (e) {
+                    throw new Error(`Server Signing Sequence Failed: ${e.message}`);
+                }
+                // Step 6: User Signing
+                let fullSignedTx;
+                try {
+                    fullSignedTx = await options.wallet.signTransaction(platformSignedTx);
+                }
+                catch (e) {
+                    throw new Error(`User Signing Failed: ${e.message}`);
+                }
+                // Step 7: Broadcast
+                try {
+                    protocolFeeTxId = await options.connection.sendRawTransaction(fullSignedTx.serialize(), {
+                        skipPreflight: false,
+                        preflightCommitment: 'confirmed'
+                    });
+                    const latestBlockhash = await options.connection.getLatestBlockhash('confirmed');
+                    await options.connection.confirmTransaction({
+                        signature: protocolFeeTxId,
+                        blockhash: latestBlockhash.blockhash,
+                        lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
+                    }, 'confirmed');
+                }
+                catch (e) {
+                    throw new Error(`Transaction Broadcast Failed: ${e.message}`);
                 }
-                const platformSignedTx = Transaction.from(platformSignedTxUint8);
-                // 4. USER SIGNATURE
-                // Now the user signs the transaction that already contains the platform's signature
-                const fullSignedTx = await options.wallet.signTransaction(platformSignedTx);
-                // 5. BROADCAST
-                // Use 'confirmed' commitment for better balance of speed and reliability on Mainnet
-                protocolFeeTxId = await options.connection.sendRawTransaction(fullSignedTx.serialize(), {
-                    skipPreflight: false,
-                    preflightCommitment: 'confirmed'
-                });
-                const latestBlockhash = await options.connection.getLatestBlockhash('confirmed');
-                await options.connection.confirmTransaction({
-                    signature: protocolFeeTxId,
-                    blockhash: latestBlockhash.blockhash,
-                    lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
-                }, 'confirmed');
                 protocolFeePaid = true;
-                console.log('✓ On-chain proof recorded with dual signatures (User + Platform)');
+                console.log('✓ On-chain proof recorded');
             }
             catch (e) {
-                console.error('Protocol fee payment failed or rejected:', e);
-                // User rejected or tx failed - clear the facehash since it wasn't recorded
+                console.error('Protocol fee payment failed:', e);
                 facehash = '';
-                // For Community Version, we fail the verification if payment is rejected
                 isOver18 = false;
-                failureReason = `Protocol fee payment failed: ${e.message || 'Verification rejected or network error'}`;
+                // Expose the EXACT error message to the user UI
+                failureReason = `Protocol Fee Error: ${e.message}`;
+                console.error('[Verify Debug Stack]', e.stack);
             }
         }
         else if (isOver18 && (!options.wallet || !options.connection)) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "solana-age-verify-sdk",
-    "version": "2.0.0-beta.7",
+    "version": "2.0.0-beta.9",
     "type": "module",
     "description": "Solana Age Verify is a premium, client-side SDK for privacy-preserving age verification and liveness detection. It generates a deterministic Face Hash linked to a wallet without storing facial data.",
     "license": "MIT",