feat: refactor method

Author: chauanhtuan185

scripts/prepublish-check.js

@@ -66,22 +66,22 @@ function checkFileSize(filePath, maxSizeKB, description) {
 function checkPackageJson() {
   return check('Package.json validation', () => {
     const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
-    
+
     const requiredFields = [
       'name', 'version', 'main', 'module', 'types', 'files',
       'author', 'license', 'description', 'repository'
     ];
-    
+
     for (const field of requiredFields) {
       if (!pkg[field]) {
         throw new Error(`Missing required field: ${field}`);
       }
     }
-    
+
     if (!pkg.name.startsWith('@lazorkit/')) {
       throw new Error('Package name must start with @lazorkit/');
     }
-    
+
     if (pkg.license !== 'MIT') {
       throw new Error('License must be MIT');
     }
@@ -103,20 +103,20 @@ function checkTypes() {
 function checkDistFiles() {
   const distFiles = [
     'dist/index.js',
-    'dist/index.esm.js', 
+    'dist/index.esm.js',
     'dist/index.d.ts'
   ];
-  
+
   const results = [];
   for (const file of distFiles) {
     results.push(checkFileExists(file, `Dist file exists: ${file}`));
   }
-  
+
   // Check file sizes
   results.push(checkFileSize('dist/index.js', 500, 'Main bundle size check'));
   results.push(checkFileSize('dist/index.esm.js', 500, 'ESM bundle size check'));
   results.push(checkFileSize('dist/index.d.ts', 200, 'Types file size check'));
-  
+
   return results;
 }
 
@@ -125,29 +125,29 @@ function checkDocumentation() {
     'README.md',
     'SECURITY.md'
   ];
-  
+
   const results = [];
   for (const doc of docs) {
     results.push(checkFileExists(doc, `Documentation exists: ${doc}`));
   }
-  
+
   return results;
 }
 
 function checkExports() {
   return check('Export verification', () => {
     const distIndex = fs.readFileSync('dist/index.d.ts', 'utf8');
-    
+
     const requiredExports = [
       'LazorKitProvider',
-      'useLazorWallet',
+      'useWallet',
       'useWalletStore',
       'WalletInfo',
       'ConnectOptions',
       'SignOptions',
       'LazorKitError'
     ];
-    
+
     for (const exportName of requiredExports) {
       if (!distIndex.includes(exportName)) {
         throw new Error(`Missing export: ${exportName}`);
@@ -158,7 +158,7 @@ function checkExports() {
 
 function main() {
   log('🚀 Starting pre-publish checks...', colors.bold + colors.blue);
-  
+
   const checks = [
     checkPackageJson(),
     checkSecurity(),
@@ -168,9 +168,9 @@ function main() {
     ...checkDocumentation(),
     checkExports()
   ];
-  
+
   const failed = checks.filter(check => !check.success);
-  
+
   if (failed.length > 0) {
     log('\n❌ Pre-publish checks failed!', colors.bold + colors.red);
     log('Please fix the issues above before publishing.', colors.red);

src/actions.ts

@@ -22,6 +22,7 @@ import {
 import { asCredentialHash, LazorkitClient, getBlockchainTimestamp, SmartWalletAction } from './contract';
 import { getFeePayer } from './core/paymaster';
 import { sha256 } from 'js-sha256';
+import { SignAndSendTransactionPayload } from './types';
 
 /**
  * Connects to the wallet
@@ -46,7 +47,7 @@ export const connectAction = async (
 
   try {
     const redirectUrl = options.redirectUrl;
-    const connectUrl = `${config.ipfsUrl}/${API_ENDPOINTS.CONNECT
+    const connectUrl = `${config.portalUrl}/${API_ENDPOINTS.CONNECT
       }&redirect_url=${encodeURIComponent(redirectUrl)}`;
 
     const resultUrl = await openBrowser(connectUrl, redirectUrl);
@@ -105,7 +106,7 @@ export const disconnectAction = async (set: (state: Partial<WalletStateClient>)
 export const signAndExecuteTransaction = async (
   get: () => WalletStateClient,
   set: (state: Partial<WalletStateClient>) => void,
-  instructions: anchor.web3.TransactionInstruction[],
+  payload: SignAndSendTransactionPayload,
   options: SignOptions
 ) => {
   const { isSigning, connection, wallet, config } = get();
@@ -134,20 +135,20 @@ export const signAndExecuteTransaction = async (
 
     const feePayer = await getFeePayer(config.configPaymaster.paymasterUrl, config.configPaymaster.apiKey);
 
-    const timestamp = await getBlockchainTimestamp(connection);
+    const timestamp = new anchor.BN(await getBlockchainTimestamp(connection));
 
     const message = await lazorProgram.buildAuthorizationMessage({
       action: {
         type: SmartWalletAction.CreateChunk,
         args: {
           policyInstruction: null,
-          cpiInstructions: instructions,
+          cpiInstructions: payload.instructions,
         }
       },
       payer: feePayer,
       smartWallet: new anchor.web3.PublicKey(wallet.smartWallet),
       passkeyPublicKey: wallet.passkeyPubkey,
-      timestamp: new anchor.BN(timestamp),
+      timestamp,
       credentialHash: asCredentialHash(
         Array.from(
           new Uint8Array(
@@ -166,16 +167,20 @@ export const signAndExecuteTransaction = async (
     const messageV0 = new anchor.web3.TransactionMessage({
       payerKey: feePayer, // PublicKey
       recentBlockhash: latestBlockhash.blockhash,
-      instructions,
+      instructions: payload.instructions,
     }).compileToV0Message();
 
     const versionedTx = new anchor.web3.VersionedTransaction(messageV0);
     const base64Tx = Buffer.from(versionedTx.serialize()).toString("base64");
     const redirectUrl = options.redirectUrl;
-    const signUrl = `${config.ipfsUrl}/${API_ENDPOINTS.SIGN}&message=${encodeURIComponent(
+    let signUrl = `${config.portalUrl}/${API_ENDPOINTS.SIGN}&message=${encodeURIComponent(
       encodedChallenge
     )}&credentialId=${encodeURIComponent(wallet.credentialId)}&transaction=${encodeURIComponent(base64Tx)}&redirect_url=${encodeURIComponent(redirectUrl)}`;
 
+    if (payload.transactionOptions?.clusterSimulation) {
+      signUrl += `&clusterSimulation=${payload.transactionOptions.clusterSimulation}`;
+    }
+
     await openSignBrowser(
       signUrl,
       redirectUrl,
@@ -196,11 +201,12 @@ export const signAndExecuteTransaction = async (
               type: SmartWalletAction.CreateChunk,
               args: {
                 policyInstruction: null,
-                cpiInstructions: instructions,
+                cpiInstructions: payload.instructions,
               }
             },
             browserResult,
-            options
+            options,
+            payload.transactionOptions
           );
           options?.onSuccess?.(txnSignature);
         } catch (error) {
@@ -228,3 +234,87 @@ export const signAndExecuteTransaction = async (
     set({ isSigning: false });
   }
 };
+
+/**
+ * Sign a message (arbitrary string or bytes)
+ *
+ * @param get - Zustand state getter function
+ * @param set - Zustand state setter function
+ * @param message - Message to sign (string)
+ * @param options - Signing options with callbacks
+ */
+export const signMessageAction = async (
+  get: () => WalletStateClient,
+  set: (state: Partial<WalletStateClient>) => void,
+  message: string,
+  options: SignOptions
+) => {
+  const { isSigning, wallet, config } = get();
+  if (isSigning) {
+    return;
+  }
+
+  if (!wallet) {
+    const error = new SigningError('No wallet connected');
+    logger.error('Sign message failed: No wallet connected');
+    options?.onFail?.(error);
+    return;
+  }
+
+  set({ isSigning: true, error: null });
+
+  try {
+    const redirectUrl = options.redirectUrl;
+    // For signMessage, we pass the message directly.
+    // The portal will treat 'transaction' param as message if it's not a valid transaction or if action is 'sign'
+    // But better to use a specific param or just rely on 'transaction' param being the message container as per portal logic
+    // PortalCommunicator: transaction: urlParams.get('transaction')
+    // TransactionReview: portalParams.transaction || portalParams.message
+    // Let's use 'message' param for clarity if portal supports it, checking portal-communicator.ts:
+    // message: urlParams.get('message') || ''
+    // So we should use 'message' param.
+
+    // If message is not base64, we might want to encode it?
+    // User passes string. Let's pass it as is, or base64 encoded?
+    // Portal expects 'message' to be displayed. If we want it to be readable, pass as string.
+    // If it's bytes, pass base64?
+    // The type signature says `message: string`. Let's assume readable string.
+
+    const signUrl = `${config.portalUrl}/${API_ENDPOINTS.SIGN}&message=${encodeURIComponent(
+      message
+    )}&credentialId=${encodeURIComponent(wallet.credentialId)}&redirect_url=${encodeURIComponent(redirectUrl)}`;
+
+    await openSignBrowser(
+      signUrl,
+      redirectUrl,
+      async (urlResult) => {
+        try {
+          const authResult = handleBrowserResult(urlResult);
+          const signature = authResult.signature;
+          const signedPayload = authResult.message;
+          options?.onSuccess?.({ signature, signedPayload });
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          logger.error('Sign message browser result processing failed:', err, { urlResult });
+          set({ error: err });
+          options?.onFail?.(err);
+        }
+      },
+      (error) => {
+        logger.error('Sign message browser failed:', error, { signUrl, redirectUrl });
+        set({ error });
+        options?.onFail?.(error);
+      }
+    );
+  } catch (error: unknown) {
+    logger.error('Sign message action failed:', error, {
+      smartWallet: wallet?.smartWallet,
+      redirectUrl: options.redirectUrl,
+    });
+    const err = error instanceof Error ? error : new SigningError('Unknown error');
+    set({ error: err });
+    options?.onFail?.(err);
+  } finally {
+    set({ isSigning: false });
+  }
+};

src/config/defaults.ts

@@ -1,5 +1,5 @@
 export const DEFAULTS = {
-  IPFS_URL: 'https://portal.lazor.sh',
+  PORTAL_URL: 'https://portal.lazor.sh',
   PAYMASTER_URL: 'https://kora.devnet.lazorkit.com',
   RPC_ENDPOINT: 'https://api.devnet.solana.com',
 } as const; 

src/contract/transaction.ts

@@ -24,34 +24,6 @@ export function prependComputeUnitLimit(
   return [createComputeUnitLimitInstruction(computeUnitLimit), ...instructions];
 }
 
-/**
- * Builds a versioned transaction (v0) from instructions
- */
-export async function buildVersionedTransaction(
-  connection: anchor.web3.Connection,
-  payer: anchor.web3.PublicKey,
-  instructions: anchor.web3.TransactionInstruction[]
-): Promise<anchor.web3.VersionedTransaction> {
-  const result = await buildTransaction(connection, payer, instructions, {
-    useVersionedTransaction: true,
-  });
-  return result.transaction as anchor.web3.VersionedTransaction;
-}
-
-/**
- * Builds a legacy transaction from instructions
- */
-export async function buildLegacyTransaction(
-  connection: anchor.web3.Connection,
-  payer: anchor.web3.PublicKey,
-  instructions: anchor.web3.TransactionInstruction[]
-): Promise<anchor.web3.Transaction> {
-  const result = await buildTransaction(connection, payer, instructions, {
-    useVersionedTransaction: false,
-  });
-  return result.transaction as anchor.web3.Transaction;
-}
-
 /**
  * Combines authentication verification instruction with smart wallet instructions
  */
@@ -94,8 +66,7 @@ export async function buildTransaction(
   options: TransactionBuilderOptions = {}
 ): Promise<TransactionBuilderResult> {
   const {
-    useVersionedTransaction,
-    addressLookupTable,
+    addressLookupTables,
     recentBlockhash: customBlockhash,
     computeUnitLimit,
   } = options;
@@ -105,18 +76,14 @@ export async function buildTransaction(
     instructions,
     computeUnitLimit
   );
-
-  // Auto-detect: if addressLookupTable is provided, use versioned transaction
-  const shouldUseVersioned = useVersionedTransaction ?? !!addressLookupTable;
+  const lookupTables = addressLookupTables ? addressLookupTables : [];
 
   // Get recent blockhash
   const recentBlockhash =
     customBlockhash || (await connection.getLatestBlockhash()).blockhash;
 
-  if (shouldUseVersioned) {
+  if (lookupTables.length > 0) {
     // Build versioned transaction
-    const lookupTables = addressLookupTable ? [addressLookupTable] : [];
-
     const message = new anchor.web3.TransactionMessage({
       payerKey: payer,
       recentBlockhash,

src/contract/types.ts

@@ -121,10 +121,8 @@ export interface PasskeySignature {
 }
 
 export interface TransactionBuilderOptions {
-  /** Use versioned transaction (v0) instead of legacy */
-  readonly useVersionedTransaction?: boolean;
-  /** Address lookup table for versioned transactions */
-  readonly addressLookupTable?: anchor.web3.AddressLookupTableAccount;
+  /** Address lookup tables for versioned transactions */
+  readonly addressLookupTables?: anchor.web3.AddressLookupTableAccount[];
   /** Custom recent blockhash (if not provided, fetched from connection) */
   readonly recentBlockhash?: string;
   /** Compute unit limit for transaction */

src/core/browser/parseResult.ts

@@ -22,13 +22,14 @@ export const handleBrowserResult = (url: string): BrowserResult => {
     const signature = parsed.searchParams.get('signature');
     const clientDataJsonBase64 = parsed.searchParams.get('clientDataJSONReturn');
     const authenticatorDataBase64 = parsed.searchParams.get('authenticatorDataReturn');
-
-    if (!signature || !clientDataJsonBase64 || !authenticatorDataBase64) {
+    const message = parsed.searchParams.get('msg');
+    if (!signature || !clientDataJsonBase64 || !authenticatorDataBase64 || !message) {
       logger.error('Browser result failed: missing signature data', {
         url,
         hasSignature: !!signature,
         hasClientData: !!clientDataJsonBase64,
         hasAuthData: !!authenticatorDataBase64,
+        hasMessage: !!message,
       });
       throw new Error('Missing signature or message from redirect');
     }
@@ -37,6 +38,7 @@ export const handleBrowserResult = (url: string): BrowserResult => {
       signature,
       clientDataJsonBase64,
       authenticatorDataBase64,
+      message,
     };
   } catch (error) {
     logger.error('Failed to handle browser result:', error, { url });