Transaction Signing

case RPCMethod.PersonalSign: {
  const [address, message] = params.sort(a => (isAddress(a) ? -1 : 1));
  const isHex = isHexString(message);

  let decodedMessage = message;
  try {
    if (isHex) {
      decodedMessage = toUtf8String(message);
    }
  } catch (err) {
    // Handle decode error
  }

  return {
    address: getAddress(address),
    message: decodedMessage,
  };
}

case RPCMethod.SignTypedData:
case RPCMethod.SignTypedDataV1:
case RPCMethod.SignTypedDataV3:
case RPCMethod.SignTypedDataV4: {
  const [address, message] = params;

  return {
    address: getAddress(address),
    message: JSON.parse(message),
  };
}

case RPCMethod.SendTransaction: {
  const [tx] = params;
  return {
    address: getAddress(tx.from),
  };
}

export async function onSessionRequest(
  event: SignClientTypes.EventArguments['session_request']
) {
  setHasPendingDeeplinkPendingRedirect(true);
  const client = await getWalletKitClient();

  const { id, topic } = event;
  const { method: _method, params } = event.params.request;
  const method = _method as RPCMethod;

  if (method === RPCMethod.Sign) {
    // Reject eth_sign for security
    await client.respondSessionRequest({
      topic,
      response: formatJsonRpcError(id, `Rainbow does not support legacy eth_sign`),
    });
    showErrorSheet({
      title: 'Request Failed',
      body: 'eth_sign is not supported for security reasons.',
      sheetHeight: 270,
    });
    return;
  }
  
  if (isSupportedMethod(method)) {
    const { address, message } = parseRPCParams({ method, params });
    
    // Build request display
    const displayDetails = await getRequestDisplayDetails(
      event.params.request,
      nativeCurrency,
      chainId
    );
    
    // Show signing sheet
    handleWalletConnectRequest(request);
  }
}

const selectedWallet = getWalletWithAccount(address);
const isReadOnly = selectedWallet?.type === WalletTypes.readOnly;

if (!selectedWallet || isReadOnly) {
  await client.respondSessionRequest({
    topic,
    response: formatJsonRpcError(id, `Wallet is read-only`),
  });
  
  showErrorSheet({
    title: 'Cannot Sign',
    body: 'This wallet is read-only and cannot sign transactions.',
    sheetHeight: 270,
  });
  return;
}

if (!address || !message) {
  await client.respondSessionRequest({
    topic,
    response: formatJsonRpcError(id, `Invalid RPC params`),
  });
  
  showErrorSheet({
    title: 'Invalid Request',
    body: 'The request has invalid or missing parameters.',
    sheetHeight: 270,
  });
  return;
}

export async function handleSessionRequestResponse(
  { sessionRequestEvent }: { sessionRequestEvent: SignClientTypes.EventArguments['session_request'] },
  { result, error }: { result: string | null; error: any }
) {
  const client = await getWalletKitClient();
  const { topic, id } = sessionRequestEvent;
  
  if (result) {
    const payload = {
      topic,
      response: formatJsonRpcResult(id, result),
    };
    await client.respondSessionRequest(payload);
  } else {
    const payload = {
      topic,
      response: formatJsonRpcError(id, error),
    };
    await client.respondSessionRequest(payload);
  }
  
  removeWalletConnectRequest({ walletConnectRequestId: sessionRequestEvent.id });
}

const authenticate: AuthRequestAuthenticateSignature = async ({ address }) => {
  const selectedWallet = getWalletWithAccount(address);
  const isHardwareWallet = selectedWallet?.type === WalletTypes.bluetooth;
  
  const signature = await (isHardwareWallet
    ? new Promise<string>((y, n) => {
        Navigation.handleAction(Routes.HARDWARE_WALLET_TX_NAVIGATOR, {
          async submit() {
            try {
              y(await loadWalletAndSignMessage());
            } catch (e) {
              n(e);
            }
          },
        });
      })
    : loadWalletAndSignMessage());
  
  return signature;
};

export function AuthRequest({
  requesterMeta,
  authenticate,
  verifiedData,
}: {
  requesterMeta: WalletKitTypes.SessionProposal['params']['proposer']['metadata'];
  authenticate: AuthRequestAuthenticateSignature;
  verifiedData?: Verify.Context['verified'];
}) {
  const auth = React.useCallback(async () => {
    const { success, reason } = await authenticate({ address });

    if (!success) {
      switch (reason) {
        case AuthRequestResponseErrorReason.ReadOnly:
          Alert({
            message: 'Please switch to a different wallet to sign this request',
            title: 'Cannot sign with this wallet',
          });
          break;
        default:
          Alert({
            title: 'Authentication Failed',
            message: 'An error occurred while authenticating.',
          });
      }
    } else {
      goBack();
    }
  }, [address, authenticate, goBack]);
}

export function addNewWalletConnectRequest({
  walletConnectRequest,
}: {
  walletConnectRequest: WalletconnectRequestData;
}): boolean {
  const state = getWalletConnectRequestsStore();
  
  // Check if request already exists
  if (state.requests.some(r => r.requestId === walletConnectRequest.requestId)) {
    return false;
  }
  
  // Add to queue
  state.requests.push(walletConnectRequest);
  return true;
}

export function removeWalletConnectRequest({
  walletConnectRequestId,
}: {
  walletConnectRequestId: number;
}) {
  const state = getWalletConnectRequestsStore();
  state.requests = state.requests.filter(
    r => r.requestId !== walletConnectRequestId
  );
}

const request: WalletconnectRequestData = {
  // ...
  walletConnectV2RequestValues: {
    sessionRequestEvent: event,
    address,
    chainId,
    onComplete(type: WalletconnectResultType) {
      if (IS_IOS) {
        Navigation.handleAction(Routes.WALLET_CONNECT_REDIRECT_SHEET, {
          type,
        });
      }
      maybeGoBackAndClearHasPendingRedirect({ delay: 300 });
    },
  },
};

analytics.track(analytics.event.wcShowingSigningRequest, {
  dappName: request.dappName,
  dappUrl: request.dappUrl,
});

analytics.track(analytics.event.wcRequestFailed, {
  type: 'session_request',
  reason: 'read only wallet',
});