fix(p2p): complete mobile bridge transaction signing flow

- PezkuwiWebView now uses signAndSend via native API
- Transactions are signed AND submitted on native side
- Returns actual block hash instead of raw signature
- Web sends section/method/args payload format
- WalletContext extracts tx details for mobile bridge

web/src/contexts/WalletContext.tsx

@@ -10,7 +10,7 @@ import { WALLET_ERRORS, formatBalance, ASSET_IDS } from '@pezkuwi/lib/wallet';
 import type { InjectedAccountWithMeta } from '@pezkuwi/extension-inject/types';
 import type { Signer } from '@pezkuwi/api/types';
 import { web3FromAddress } from '@pezkuwi/extension-dapp';
-import { isMobileApp, getNativeWalletAddress, signTransactionNative } from '@/lib/mobile-bridge';
+import { isMobileApp, getNativeWalletAddress, signTransactionNative, type TransactionPayload } from '@/lib/mobile-bridge';
 
 interface TokenBalances {
   HEZ: string;
@@ -170,16 +170,38 @@ export const WalletProvider: React.FC<{ children: React.ReactNode }> = ({ childr
       if (isMobileApp()) {
         if (import.meta.env.DEV) console.log('[Mobile] Using native bridge for transaction signing');
 
-        // Get extrinsic hex for native signing
-        const extrinsicHex = (tx as { toHex?: () => string }).toHex?.() || '';
+        // Extract transaction details from the tx object
+        const txAny = tx as {
+          method: {
+            section: string;
+            method: string;
+            args: unknown[];
+            toHuman?: () => { args?: Record<string, unknown> };
+          };
+        };
 
-        // Sign via native bridge
-        const signature = await signTransactionNative(extrinsicHex);
+        // Get section, method and args from the transaction
+        const section = txAny.method.section;
+        const method = txAny.method.method;
 
-        // Submit the signed transaction
-        // Note: The native app signs and may also submit, so we return the signature as hash
-        // In production, the mobile app handles the full submit flow
-        return signature;
+        // Extract args - convert to array format
+        const argsHuman = txAny.method.toHuman?.()?.args || {};
+        const args = Object.values(argsHuman);
+
+        if (import.meta.env.DEV) {
+          console.log('[Mobile] Transaction details:', { section, method, args });
+        }
+
+        const payload: TransactionPayload = { section, method, args };
+
+        // Sign and send via native bridge
+        const blockHash = await signTransactionNative(payload);
+
+        if (import.meta.env.DEV) {
+          console.log('[Mobile] Transaction submitted, block hash:', blockHash);
+        }
+
+        return blockHash;
       }
 
       // Desktop: Use browser extension for signing

web/src/lib/mobile-bridge.ts

@@ -19,7 +19,7 @@ declare global {
       postMessage: (message: string) => void;
     };
     PezkuwiNativeBridge?: {
-      signTransaction: (extrinsicHex: string, callback: (signature: string | null, error: string | null) => void) => void;
+      signTransaction: (payload: { section: string; method: string; args: unknown[] }, callback: (hash: string | null, error: string | null) => void) => void;
       connectWallet: () => void;
       goBack: () => void;
       isWalletConnected: () => boolean;
@@ -83,29 +83,57 @@ export function requestNativeWalletConnection(): void {
   window.PezkuwiNativeBridge?.connectWallet();
 }
 
+export interface TransactionPayload {
+  section: string;
+  method: string;
+  args: unknown[];
+}
+
 /**
- * Sign transaction using native wallet
- * Returns a promise that resolves with the signature or rejects with error
+ * Sign and submit transaction using native wallet
+ * Returns a promise that resolves with the block hash or rejects with error
  */
-export function signTransactionNative(extrinsicHex: string): Promise<string> {
+export function signTransactionNative(payload: TransactionPayload): Promise<string> {
   return new Promise((resolve, reject) => {
     if (!isMobileApp() || !window.PezkuwiNativeBridge) {
       reject(new Error('Native bridge not available'));
       return;
     }
 
-    window.PezkuwiNativeBridge.signTransaction(extrinsicHex, (signature, error) => {
+    window.PezkuwiNativeBridge.signTransaction(payload, (hash, error) => {
       if (error) {
         reject(new Error(error));
-      } else if (signature) {
-        resolve(signature);
+      } else if (hash) {
+        resolve(hash);
       } else {
-        reject(new Error('No signature returned'));
+        reject(new Error('No transaction hash returned'));
       }
     });
   });
 }
 
+/**
+ * Legacy: Sign transaction using native wallet (raw hex - deprecated)
+ * @deprecated Use signTransactionNative with TransactionPayload instead
+ */
+export function signTransactionNativeHex(extrinsicHex: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    if (!isMobileApp() || !window.ReactNativeWebView) {
+      reject(new Error('Native bridge not available'));
+      return;
+    }
+
+    // For backwards compatibility, send as legacy format
+    window.ReactNativeWebView.postMessage(JSON.stringify({
+      type: 'SIGN_TRANSACTION_LEGACY',
+      payload: { extrinsicHex }
+    }));
+
+    // Note: This won't work without proper callback handling
+    reject(new Error('Legacy signing not supported - use TransactionPayload'));
+  });
+}
+
 /**
  * Navigate back in native app
  */