Sign Transaction

// ❌ Don't store in localStorage for sensitive transactions
localStorage.setItem('signedTx', signedTransaction);

// ✅ Store securely on your backend
await fetch('/api/store-transaction', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${userToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    signedTransaction,
    userId: user.id,
    timestamp: Date.now()
  })
});

import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';

const publicClient = createPublicClient({
  chain: mainnet,
  transport: http()
});

// Get current nonce
const currentNonce = await publicClient.getTransactionCount({
  address: user.wallet.address as `0x${string}`
});

// Sign multiple transactions with incremental nonces
const signedTxs = [];
for (let i = 0; i < transactions.length; i++) {
  const result = await signTransaction({
    ...transactions[i],
    nonce: currentNonce + i,
    chainId: 1
  });
  signedTxs.push(result.signedTransaction);
}

import { isAddress } from 'viem';

const handleSign = async () => {
  // Validate address
  if (!isAddress(recipient)) {
    alert('Invalid recipient address');
    return;
  }

  // Validate amount
  if (BigInt(value) <= 0n) {
    alert('Amount must be greater than 0');
    return;
  }

  // Validate chain ID
  const supportedChains = [1, 8453, 137];
  if (!supportedChains.includes(chainId)) {
    alert('Unsupported chain');
    return;
  }

  // Proceed with signing
  await signTransaction({ to: recipient, value, chainId });
};

interface StoredTransaction {
  signedTransaction: string;
  createdAt: number;
  expiresAt: number;
}

const storeSignedTransaction = (signedTx: string) => {
  const now = Date.now();
  const expires = now + (5 * 60 * 1000); // 5 minutes

  const stored: StoredTransaction = {
    signedTransaction: signedTx,
    createdAt: now,
    expiresAt: expires
  };

  localStorage.setItem('signedTx', JSON.stringify(stored));
};

const getSignedTransaction = (): string | null => {
  const stored = localStorage.getItem('signedTx');
  if (!stored) return null;

  const data: StoredTransaction = JSON.parse(stored);

  // Check if expired
  if (Date.now() > data.expiresAt) {
    localStorage.removeItem('signedTx');
    return null;
  }

  return data.signedTransaction;
};

const [status, setStatus] = useState<'idle' | 'signing' | 'signed' | 'error'>('idle');

const handleSign = async () => {
  setStatus('signing');

  try {
    const result = await signTransaction({ to: '0x...', value: '0x38d7ea4c68000', chainId: 1 });
    setStatus('signed');
    console.log('Transaction signed:', result.signedTransaction);
  } catch (error) {
    setStatus('error');
    console.error('Signing failed:', error);
  }
};

return (
  <div>
    <button onClick={handleSign} disabled={status === 'signing'}>
      {status === 'signing' && 'Signing...'}
      {status === 'signed' && 'Signed ✓'}
      {status === 'error' && 'Failed ✗'}
      {status === 'idle' && 'Sign Transaction'}
    </button>
    {status === 'signed' && <p>Transaction signed successfully. Ready to broadcast.</p>}
  </div>
);

try {
  const txHash = await publicClient.sendRawTransaction({
    serializedTransaction: signedTransaction as `0x${string}`
  });
} catch (error: any) {
  if (error.message.includes('nonce')) {
    alert('Transaction nonce is invalid. Please sign again.');
  } else if (error.message.includes('underpriced')) {
    alert('Gas price is too low. Please sign with higher gas.');
  } else {
    console.error('Broadcast error:', error);
  }
}

try {
  const result = await signTransaction({ to: '0x...', value: '0x38d7ea4c68000', chainId: 1 });
} catch (error: any) {
  if (error.code === 'USER_REJECTED') {
    // Don't show error - this is expected behavior
    console.log('User cancelled signing');
    return;
  }
  // Handle other errors
  alert('Signing failed: ' + error.message);
}

const CHAIN_IDS = {
  mainnet: 1,
  base: 8453,
  polygon: 137,
  arbitrum: 42161,
  optimism: 10
};

const handleSign = async (network: keyof typeof CHAIN_IDS) => {
  const chainId = CHAIN_IDS[network];

  await signTransaction({
    to: '0x...',
    value: '0x38d7ea4c68000',
    chainId
  });
};