Merge pull request #12 from lazor-kit/feat/support-kora-client-sdk

Feat/support kora client sdk

Author: chauanhtuan185

README.md

@@ -1,6 +1,6 @@
 {
   "name": "@lazorkit/wallet-mobile-adapter",
-  "version": "1.3.74",
+  "version": "1.4.0",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
   "types": "dist/index.d.ts",
@@ -42,10 +42,11 @@
     "url": "https://github.com/lazorkit/wallet-mobile-adapter/issues"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
   },
   "devDependencies": {
     "@eslint/js": "9.33.0",
+    "@rollup/plugin-commonjs": "28.0.6",
     "@rollup/plugin-json": "6.1.0",
     "@rollup/plugin-node-resolve": "16.0.1",
     "@types/bn.js": "^5.2.0",
@@ -54,6 +55,7 @@
     "eslint": "9.33.0",
     "eslint-plugin-react": "7.37.5",
     "globals": "16.3.0",
+    "react-native": ">=0.70.0",
     "rollup": "4.46.0",
     "rollup-plugin-dts": "6.2.1",
     "rollup-plugin-peer-deps-external": "2.2.4",
@@ -63,13 +65,16 @@
   },
   "dependencies": {
     "@coral-xyz/anchor": "0.31.1",
-    "@react-native-async-storage/async-storage": "2.2.0",
-    "@rollup/plugin-commonjs": "28.0.6",
+    "@react-native-async-storage/async-storage": "^2.2.0",
     "buffer": "6.0.3",
+    "expo-crypto": "^15.0.8",
     "expo-web-browser": "^14.2.0",
     "js-sha256": "0.11.1",
-    "react-native": "^0.82.1",
     "react-native-get-random-values": "^1.11.0",
     "zustand": "^5.0.7"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.70.0"
   }
 }

package.json

@@ -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);

scripts/prepublish-check.js

@@ -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(
@@ -162,11 +163,23 @@ export const signAndExecuteTransaction = async (
       .replace(/\+/g, '-')
       .replace(/\//g, '_')
       .replace(/=+$/, '');
+    const latestBlockhash = await connection.getLatestBlockhash();
+    const messageV0 = new anchor.web3.TransactionMessage({
+      payerKey: feePayer, // PublicKey
+      recentBlockhash: latestBlockhash.blockhash,
+      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
-    )}&redirect_url=${encodeURIComponent(redirectUrl)}`;
+    )}&credentialId=${encodeURIComponent(wallet.credentialId)}&transaction=${encodeURIComponent(base64Tx)}&redirect_url=${encodeURIComponent(redirectUrl)}`;
+
+    if (payload.transactionOptions?.clusterSimulation) {
+      signUrl += `&clusterSimulation=${payload.transactionOptions.clusterSimulation}`;
+    }
 
     await openSignBrowser(
       signUrl,
@@ -188,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) {
@@ -220,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/actions.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/config/defaults.ts

@@ -405,6 +405,7 @@ export class LazorkitClient {
         smartWallet: walletDevice.smartWallet,
         walletState: this.getWalletStatePubkey(walletDevice.smartWallet),
         walletDevice: account.pubkey,
+        passkeyPubkey: walletDevice.passkeyPubkey,
       };
     }
   }