improvements

Author: TheTrunk

package.json

@@ -39,7 +39,7 @@
     "@runonflux/aa-schnorr-multisig-sdk": "1.2.1",
     "@runonflux/flux-sdk": "1.1.0",
     "@runonflux/react-native-step-indicator": "1.0.0",
-    "@runonflux/solana-multisig": "0.3.0",
+    "@runonflux/solana-multisig": "0.8.1",
     "@runonflux/utxo-lib": "1.0.2",
     "@scure/bip32": "2.0.1",
     "@scure/bip39": "2.0.1",

src/components/SyncSuccess/SyncSuccess.tsx

@@ -10,7 +10,7 @@ import {
 import Icon from 'react-native-vector-icons/Feather';
 import { useTranslation } from 'react-i18next';
 import { useTheme } from '../../hooks';
-import { backends } from '@storage/backends';
+import { explorerAddressUrl } from '../../lib/explorerUrl';
 import { cryptos } from '../../types';
 import * as Keychain from 'react-native-keychain';
 import Toast from 'react-native-toast-message';
@@ -95,10 +95,7 @@ const SyncSuccess = (props: {
 
   const openExplorer = () => {
     console.log('Open Explorer');
-    const backendConfig = backends()[props.chain];
-    Linking.openURL(
-      `https://${backendConfig.explorer ?? backendConfig.node}/address/${chainAddress}`,
-    );
+    Linking.openURL(explorerAddressUrl(props.chain, chainAddress));
   };
 
   return (

src/components/TxSent/TxSent.tsx

@@ -10,7 +10,7 @@ import {
 import Icon from 'react-native-vector-icons/Feather';
 import { useTranslation } from 'react-i18next';
 import { useTheme } from '../../hooks';
-import { backends } from '@storage/backends';
+import { explorerTxUrl } from '../../lib/explorerUrl';
 import BlurOverlay from '../../BlurOverlay';
 
 import { cryptos } from '../../types';
@@ -31,10 +31,7 @@ const TxSent = (props: {
 
   const openExplorer = () => {
     console.log('Open Explorer');
-    const backendConfig = backends()[props.chain];
-    Linking.openURL(
-      `https://${backendConfig.explorer ?? backendConfig.node}/tx/${props.txid}`,
-    );
+    Linking.openURL(explorerTxUrl(props.chain, props.txid));
   };
 
   return (

src/lib/constructTx.ts

@@ -392,22 +392,26 @@ export async function signAndBroadcastEVM(
 // ============================================================================
 
 /**
- * Co-sign a partially-signed Solana tx and submit to the relay's paymaster
- * broadcast endpoint (which adds the feePayer signature and broadcasts).
+ * UTXO/EVM-style Solana co-sign + broadcast on the Key device.
  *
- * Used by ssp-key when it receives an action `tx` for `chainType === 'sol'`.
- * Wallet has already partial-signed; key adds its own partial-sig (member
- * ix authorization). The relay paymaster pays tx fees + auto-tops-up
- * member signers for proposal rent.
+ * Wallet partial-signs the outer tx with its leaf and posts the serialized
+ * tx as a bare base64 string in the standard `tx` action. Key adds its own
+ * leaf signature and broadcasts via the relay's paymaster endpoint,
+ * mirroring how UTXO/EVM `tx` actions are handled.
  *
- * Returns the broadcast signature.
+ * Same flow for first / subsequent sends — when the multisig PDA isn't
+ * initialized yet, wallet's tx contains a leading permissionless
+ * `initialize_multisig` ix (no member sigs required), and Key never has
+ * to know the difference.
+ *
+ * Returns the broadcast signature (used as txid for the existing TxSent UI).
  */
 export async function cosignAndBroadcastSOLTransaction(opts: {
   chain: keyof cryptos;
   serializedTxBase64: string;
   keyPubkeyBase58: string;
-  keyPrivKeyHex: string; // 64-byte Ed25519 secret key (hex)
-  relayHost: string; // e.g., 'relay.sspwallet.com'
+  keyPrivKeyHex: string;
+  relayHost: string;
 }): Promise<string> {
   const { Transaction, Keypair } = await import('@solana/web3.js');
 
@@ -420,8 +424,6 @@ export async function cosignAndBroadcastSOLTransaction(opts: {
   const tx = Transaction.from(Buffer.from(opts.serializedTxBase64, 'base64'));
   tx.partialSign(keyKeypair);
 
-  // Submit to relay's paymaster broadcast endpoint instead of direct RPC.
-  // The relay adds the feePayer (paymaster) signature and broadcasts.
   const serializedTxBase64 = tx
     .serialize({ requireAllSignatures: false, verifySignatures: false })
     .toString('base64');

src/lib/explorerUrl.ts

@@ -0,0 +1,45 @@
+/**
+ * Build explorer URLs for tx and address links.
+ *
+ * Solana Explorer requires a `?cluster=<network>` query param to look up
+ * non-mainnet entries — without it, devnet txs/addresses 404 silently
+ * because the page defaults to `mainnet-beta`. UTXO/EVM explorers don't
+ * need any extra query params.
+ */
+import { backends } from '@storage/backends';
+import { blockchains } from '@storage/blockchains';
+
+function solanaCluster(chain: string): string | null {
+  if (chain === 'solDevnet') return 'devnet';
+  // future-proofing: 'sol' would be mainnet (no cluster param needed),
+  // 'solTestnet' would be 'testnet', etc.
+  return null;
+}
+
+function withSolanaCluster(url: string, chain: string): string {
+  const cluster = solanaCluster(chain);
+  if (!cluster) return url;
+  const sep = url.includes('?') ? '&' : '?';
+  return `${url}${sep}cluster=${cluster}`;
+}
+
+function explorerHost(chain: string): string {
+  const cfg = backends()[chain];
+  return cfg.explorer ?? cfg.node ?? '';
+}
+
+/** Explorer URL for a transaction by signature/hash. */
+export function explorerTxUrl(chain: string, txid: string): string {
+  const base = `https://${explorerHost(chain)}/tx/${txid}`;
+  return withSolanaCluster(base, chain);
+}
+
+/** Explorer URL for an address. */
+export function explorerAddressUrl(chain: string, address: string): string {
+  const base = `https://${explorerHost(chain)}/address/${address}`;
+  return withSolanaCluster(base, chain);
+}
+
+export function isSolanaChain(chain: string): boolean {
+  return blockchains[chain]?.chainType === 'sol';
+}

src/lib/transactions.ts

@@ -1,4 +1,5 @@
 import BigNumber from 'bignumber.js';
+import QuickCrypto from 'react-native-quick-crypto';
 import utxolib from '@runonflux/utxo-lib';
 import { decodeFunctionData, erc20Abi } from 'viem';
 import * as abi from '@runonflux/aa-schnorr-multisig-sdk/dist/abi';
@@ -267,7 +268,21 @@ export async function decodeTransactionForApproval(
       return decodedTx;
     }
     if (blockchains[chain].chainType === 'sol') {
-      const decodedTx = await decodeSOLTransactionForApproval(rawTx, chain);
+      // Single-roundtrip flow: payload is JSON wrapping the unsigned tx
+      // plus init metadata. Older callers pass a bare base64 tx string.
+      let serializedForDecode = rawTx;
+      try {
+        const parsed = JSON.parse(rawTx) as { unsignedTxBase64?: string };
+        if (parsed && typeof parsed.unsignedTxBase64 === 'string') {
+          serializedForDecode = parsed.unsignedTxBase64;
+        }
+      } catch {
+        // Not JSON — fall through to decode rawTx directly.
+      }
+      const decodedTx = await decodeSOLTransactionForApproval(
+        serializedForDecode,
+        chain,
+      );
       return decodedTx;
     }
     const libID = getLibId(chain);
@@ -525,34 +540,17 @@ export async function decodeEVMTransactionForApproval(
   }
 }
 
-/**
- * Decode an SSP Solana Multisig transaction for the key device's approval
- * screen. The wallet hands the key a base64-encoded outer Solana Transaction
- * containing a `create_transaction` ix; that ix's data carries the proposal
- * `TransactionMessage` inline (borsh-encoded) describing the user's intended
- * transfer.
- *
- * Two transfers are typically present in the proposal:
- *   1. user transfer: vault → recipient (this is what the user is sending)
- *   2. paymaster reimbursement: vault → feePayer (this is the fee — the
- *      paymaster signs the outer tx's feePayer slot and gets reimbursed
- *      in-tx so its balance stays flat)
- *
- * We identify the fee transfer by matching destination = outer tx feePayer.
- * Anything else SystemProgram.transfer'd from the vault is the user's send.
- *
- * For SPL token transfers (TOKEN_PROGRAM ix), the recipient shown is the
- * destination ATA — Solana explorers resolve ATAs to their owner so the
- * user can verify on-chain that the ATA belongs to who they intended.
- */
+// Decode an SSP Solana proposal for the approval screen. Splits the
+// proposal's transfers into the user's send (vault → recipient) and the
+// fee (vault → outer feePayer = paymaster). SPL transfers show the
+// destination ATA as the receiver; explorers resolve ATAs to owners.
 async function decodeSOLTransactionForApproval(
   rawTxBase64: string,
   chain: keyof cryptos,
 ): Promise<tokenInfo> {
   try {
     const { Transaction, PublicKey, SystemProgram } =
       await import('@solana/web3.js');
-    const { createHash } = require('crypto') as typeof import('crypto');
     const decimals = blockchains[chain].decimals;
     const tokenSymbol = blockchains[chain].symbol;
 
@@ -562,25 +560,35 @@ async function decodeSOLTransactionForApproval(
     }
     const paymasterPubkey = tx.feePayer;
 
-    // Find the create_transaction ix (matches Anchor discriminator
-    // sha256("global:create_transaction")[:8]).
-    const createIxDiscriminator: Buffer = createHash('sha256')
-      .update('global:create_transaction')
-      .digest()
-      .subarray(0, 8);
-    const createIx = tx.instructions.find(
-      (ix) =>
-        ix.data.length >= 8 &&
-        ix.data.subarray(0, 8).equals(createIxDiscriminator),
-    );
+    // Compute the create_transaction discriminator (first 8 bytes of
+    // sha256("global:create_transaction")) using react-native-quick-crypto
+    // — Node's `crypto.createHash` isn't available in RN, and utxolib's
+    // sha256 wasn't reachable from this RN bundle either.
+    const createIxDiscriminator: Buffer = Buffer.from(
+      QuickCrypto.createHash('sha256')
+        .update('global:create_transaction')
+        .digest(),
+    ).subarray(0, 8);
+    console.log(createIxDiscriminator);
+    console.log(tx.instructions);
+    // `ix.data` from `Transaction.from(...)` is typed as Buffer but the
+    // RN runtime can deliver a plain JS array of numbers (no `.subarray`,
+    // no `.readUInt32LE`, no `.equals`). Compare byte-by-byte using only
+    // index access, then `Buffer.from(...)` the matched ix's data so all
+    // the parser helpers below have a real Buffer to work with.
+    const createIx = tx.instructions.find((ix) => {
+      if (!ix.data || ix.data.length < 8) return false;
+      for (let i = 0; i < 8; i++) {
+        if ((ix.data as ArrayLike<number>)[i] !== createIxDiscriminator[i])
+          return false;
+      }
+      return true;
+    });
     if (!createIx) {
       throw new Error('Solana tx does not contain a create_transaction ix');
     }
-
-    // Borsh-decode the proposal message inline from ix data:
-    //   8 bytes discriminator + 1 byte vault_index + TransactionMessage
-    const data = createIx.data;
-    let off = 8 + 1 + 3; // skip disc + vault_index + 3-byte header
+    const data = Buffer.from(createIx.data as ArrayLike<number>);
+    let off = 8 + 1 + 3; // skip discriminator + vault_index + 3-byte header
     const accountKeysLen = data.readUInt32LE(off);
     off += 4;
     const accountKeys: InstanceType<typeof PublicKey>[] = [];
@@ -605,71 +613,51 @@ async function decodeSOLTransactionForApproval(
       off += 1;
       const aiLen = data.readUInt32LE(off);
       off += 4;
-      const accountIdxs = data.subarray(off, off + aiLen);
+      const accountIdxs = Buffer.from(data.subarray(off, off + aiLen));
       off += aiLen;
       const ixDataLen = data.readUInt32LE(off);
       off += 4;
-      const ixData = data.subarray(off, off + ixDataLen);
+      const ixData = Buffer.from(data.subarray(off, off + ixDataLen));
       off += ixDataLen;
 
       const ixProgram = accountKeys[programIdIdx];
       if (!ixProgram) continue;
 
-      // SystemProgram.transfer (native SOL).
       if (ixProgram.equals(SystemProgram.programId)) {
         if (ixData.length < 12 || ixData.readUInt32LE(0) !== 2) continue;
         if (accountIdxs.length < 2) continue;
         const fromIdx = accountIdxs[0];
-        const toIdx = accountIdxs[1];
-        const toPubkey = accountKeys[toIdx];
+        const toPubkey = accountKeys[accountIdxs[1]];
         if (!toPubkey) continue;
         const amountLamports = ixData.readBigUInt64LE(4).toString();
         if (toPubkey.equals(paymasterPubkey)) {
-          // Reimbursement to paymaster — this is the fee.
           feeBase = new BigNumber(feeBase).plus(amountLamports).toFixed();
         } else {
-          // User's actual transfer.
           vaultPubkey = accountKeys[fromIdx];
           userReceiver = toPubkey.toBase58();
           userAmountBase = amountLamports;
         }
         continue;
       }
 
-      // SPL token transfer (TOKEN_PROGRAM):
-      //   accountIndexes: [source_ata, dest_ata, authority]
-      //   data tag 3 = Transfer (legacy), tag 12 = TransferChecked
+      // SPL Transfer (tag 3) or TransferChecked (tag 12); accountIndexes
+      // are [source_ata, dest_ata, authority]. Mint isn't in the proposal,
+      // so symbol stays generic — explorer resolves ATA → mint → symbol.
       if (ixProgram.toBase58() === TOKEN_PROGRAM) {
         const tag = ixData.readUInt8(0);
-        let tokenAmount: string | null = null;
-        if (tag === 3 && ixData.length >= 9) {
-          tokenAmount = ixData.readBigUInt64LE(1).toString();
-        } else if (tag === 12 && ixData.length >= 9) {
-          tokenAmount = ixData.readBigUInt64LE(1).toString();
-        } else {
-          continue;
-        }
+        if ((tag !== 3 && tag !== 12) || ixData.length < 9) continue;
         if (accountIdxs.length < 2) continue;
-        const destAtaIdx = accountIdxs[1];
-        const destAta = accountKeys[destAtaIdx];
+        const destAta = accountKeys[accountIdxs[1]];
         if (!destAta) continue;
         userReceiver = destAta.toBase58();
-        userAmountBase = tokenAmount;
-
-        // Look up token metadata from chain spec for symbol/decimals/contract.
-        // The proposal doesn't carry the mint address directly in the ix
-        // accountIndexes for legacy Transfer (only source ATA, dest ATA,
-        // authority). Inferring the mint requires either an RPC call or
-        // off-chain knowledge from chain spec. For now: leave userTokenSymbol
-        // generic; explorer link resolves ATA → mint → symbol.
+        userAmountBase = ixData.readBigUInt64LE(1).toString();
         userTokenSymbol = '(token)';
         continue;
       }
     }
 
-    // Convert base units to display units. For native SOL the chain decimals
-    // apply; for SPL we'd need the mint's decimals (not retrievable from the
-    // proposal alone — show raw base units in that case).
+    // SPL amounts stay in base units since the proposal doesn't carry the
+    // mint's decimals; native SOL converts via the chain's decimals.
     const isNative = userTokenSymbol === tokenSymbol;
     const displayAmount = isNative
       ? new BigNumber(userAmountBase).dividedBy(10 ** decimals).toFixed()

src/lib/wallet.ts

@@ -11,7 +11,6 @@ import { PublicKey } from '@solana/web3.js';
 import {
   deriveMultisigAddress as deriveSolanaMultisigAddress,
   deriveVaultAddress as deriveSolanaVaultAddress,
-  createInitializationMessage,
 } from '@runonflux/solana-multisig';
 import {
   keyPair,
@@ -450,26 +449,6 @@ export function generateMultisigAddressSOL(
   };
 }
 
-/**
- * Sign the SSP Solana Multisig init message off-chain. Returns base64
- * Ed25519 signature. See ssp-wallet's wallet.ts for the message format.
- */
-export function signSolanaInitMessage(
-  privKeyHex: string,
-  walletPubkeyBase58: string,
-  keyPubkeyBase58: string,
-): string {
-  const members = [
-    new PublicKey(walletPubkeyBase58),
-    new PublicKey(keyPubkeyBase58),
-  ];
-  const threshold = 2;
-  const message = createInitializationMessage(members, threshold);
-  const secretKey = new Uint8Array(Buffer.from(privKeyHex, 'hex'));
-  const signature = nacl.sign.detached(message, secretKey);
-  return Buffer.from(signature).toString('base64');
-}
-
 // given xpriv of our party, generate keypair consisting of privateKey in WIF format and public key belonging to it
 export function generateAddressKeypair(
   xpriv: string,