accept base 64 input for solana tx (#59)

Author: Ellzer

apps/solana/src/parser.ts

@@ -19,6 +19,7 @@ import {
   type StakeInstructionParams,
   type SystemInstructionParams,
 } from '@/types';
+import { base64ToHex, isBase64, isHex } from '@/utils';
 
 export type MessageLike = {
   header: {
@@ -31,8 +32,6 @@ export type MessageLike = {
   instructions: { programIdIndex: number; accounts: number[]; data: string }[];
 };
 
-const isHex = (s: string) => /^[0-9a-fA-F]+$/.test(s) && s.length % 2 === 0;
-
 export const looksLikeMessage = (obj: unknown): obj is MessageLike => {
   const msg = obj as Record<string, unknown>;
   return !!msg.header && !!msg.recentBlockhash && !!msg.accountKeys && !!msg.instructions;
@@ -321,16 +320,26 @@ export const parseSolTx = (txRaw: string): ParseSolTxResult => {
         };
       }
     } catch {
-      // fall through to hex path
+      // fall through to hex/base64 path
+    }
+  }
+
+  // Check if input is base64, if so convert to hex
+  let hexInput = input;
+  if (!isHex(input) && isBase64(input)) {
+    try {
+      hexInput = base64ToHex(input);
+    } catch (error) {
+      throw new Error('Failed to decode base64 input');
     }
   }
 
-  if (!isHex(input)) {
-    throw new Error('Input is not valid hex or Fireblocks message JSON');
+  if (!isHex(hexInput)) {
+    throw new Error('Input is not valid hex, base64, or Fireblocks message JSON');
   }
 
   try {
-    const buffer = Buffer.from(input, 'hex');
+    const buffer = Buffer.from(hexInput, 'hex');
 
     const tx = Transaction.from(buffer);
     const parsedInstructions = tx.instructions.map(safeDecode);

apps/solana/src/solana-adapter.tsx

@@ -2,6 +2,7 @@ import { type ProtocolAdapter, SOL } from '@protocols/shared';
 import { Summary } from '@/components/Summary';
 import { convertToMessage, looksLikeMessage, type MessageLike, type ParseSolTxResult, parseSolTx } from '@/parser';
 import type { DecodedInstruction } from '@/types';
+import { base64ToHex, isBase64, isHex } from '@/utils';
 
 const computeSolanaHash = async (rawTx: string): Promise<string> => {
   try {
@@ -27,7 +28,12 @@ const computeSolanaHash = async (rawTx: string): Promise<string> => {
       } catch {}
     }
 
-    const transactionUint8Array = new Uint8Array(input.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16)) || []);
+    let hexInput = input;
+    if (!isHex(input) && isBase64(input)) {
+      hexInput = base64ToHex(input);
+    }
+
+    const transactionUint8Array = new Uint8Array(hexInput.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16)) || []);
     const hashBuffer = await crypto.subtle.digest('SHA-256', transactionUint8Array);
     const hashArray = Array.from(new Uint8Array(hashBuffer));
     return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
@@ -40,16 +46,23 @@ const isValidSolanaInput = (rawTx: string): boolean => {
   const input = rawTx.trim();
   if (!input) return false;
 
+  // JSON
   if (input.startsWith('{') || input.startsWith('[')) return true;
 
-  return /^[0-9a-fA-F]+$/.test(input) && input.length % 2 === 0;
+  // Hex
+  if (isHex(input)) return true;
+
+  // Base64
+  if (isBase64(input)) return true;
+
+  return false;
 };
 
 export const solanaAdapter: ProtocolAdapter<ParseSolTxResult> = {
   protocol: SOL,
   name: 'solana',
   displayName: 'Solana',
-  placeholder: 'Paste your transaction as hex or Fireblocks message JSON',
+  placeholder: 'Paste your transaction as hex, base64, or Fireblocks message JSON',
 
   validateInput: isValidSolanaInput,
   parseTransaction: async (rawTx) => parseSolTx(rawTx),

apps/solana/src/utils.ts

@@ -1,3 +1,21 @@
 export const solExplorerLink = (hash: string, type: 'tx' | 'address') => {
   return `https://solscan.io/${type}/${hash}`;
 };
+
+export const isHex = (s: string): boolean => {
+  return /^[0-9a-fA-F]+$/.test(s) && s.length % 2 === 0;
+};
+
+export const isBase64 = (s: string): boolean => {
+  return /^[A-Za-z0-9+/]+={0,2}$/.test(s) && s.length % 4 === 0;
+};
+
+export const base64ToHex = (base64: string): string => {
+  const binary = atob(base64);
+  let hex = '';
+  for (let i = 0; i < binary.length; i++) {
+    const byte = binary.charCodeAt(i).toString(16).padStart(2, '0');
+    hex += byte;
+  }
+  return hex;
+};