> ## Documentation Index
> Fetch the complete documentation index at: https://developers.particle.network/llms.txt
> Use this file to discover all available pages before exploring further.

# Particle Auth FAQ

> Find Frequently Asked Questions about Particle Auth.

<AccordionGroup>
  <Accordion title="How can I ensure the signature result is consistent each time?" icon="signature">
    **Answer:** Due to the unique characteristics of Multi-Party Computation (MPC), the signature result for the same message can vary each time, unlike traditional private key wallets such as MetaMask.

    To address scenarios requiring a consistent signature result, we provide the `uniq` parameter. This parameter ensures that the signature remains consistent every time you sign the same message.

    ```tsx App.tsx theme={null}
    // Sign a message with the uniq flag
    const result = await signMessage(message, true);
    ```
  </Accordion>

  <Accordion title="How can I silently log in and sign messages/transactions?" icon="key">
    **Answer:** Currently, silent login and signing are not directly supported. However, this functionality can be achieved using the following approaches:

    1. **[Session Keys](https://your-link-to-guides/integrations/aa/keys#implementing-session-keys)** with Biconomy V2:
       Session keys enable silent signing by creating temporary keys with limited permissions and expiration, allowing you to bypass frequent authentication popups.

    2. **Enabling Blind Signatures with Particle Auth:**
       Blind signing (signing without a confirmation popup) is possible in Particle Auth if specific conditions are met:

       * **Authentication Method:** The user must be authenticated via JWT or Telegram.
       * **Master Password Requirement:**
         * The user has entered their master password, or
         * The user has not set a master password.
       * **No Payment Password:** The user has not set a payment password.
       * **Disable Payment Password Prompt:** Configure `AuthCoreContextProvider` with the parameter `promptPaymentPasswordSettingWhenSign` set to `false`.

       ```javascript theme={null}
       // Configuration for disabling payment password prompt
       const promptSettingConfig = {
           promptPaymentPasswordSettingWhenSign: false,
       };
       ```

       When these conditions are satisfied, blind signing is enabled.
  </Accordion>

  <Accordion title="How do I determine if an account is new?" icon="user-plus">
    **Answer:** When you retrieve `UserInfo`, either through the `connect` method or via the `userInfo` object from `useAuthCore`, a field provide the relevant information:

    * **Account Creation:** The `created_at` field indicates the timestamp when the account was created.

    <Note>Find more about Handling User Information in the [Particle Auth SDK](/social-logins/auth/desktop-sdks/web#handling-user-information) page.</Note>
  </Accordion>

  <Accordion title="How can I check the status of the main password and payment password settings?" icon="lock">
    **Answer:** The `userInfo` object contains a `security_account` property, which includes two fields:

    * `has_set_master_password`: Indicates if the master password is set.
    * `has_set_payment_password`: Indicates if the payment password is set.

    <Note>Find more about Handling User Information in the [Particle Auth SDK](/social-logins/auth/desktop-sdks/web#handling-user-information) page.</Note>
  </Accordion>

  <Accordion title="Why does Google login prompt me that I do not comply with the policy?" icon="shield">
    **Answer:** This issue typically occurs when using Google login within a WebView environment.

    * [Google Support](https://support.google.com/accounts/answer/12917337?hl=en#zippy=%2Cdisallowed-useragent).
  </Accordion>

  <Accordion title="How to add support for a new EVM chain?" icon="ethereum">
    **Answer:** Our team needs to implement support for integrating a new EVM chain on our platform. Once we have added support for the chain, developers can use it within their applications.

    <Note>Please [contact us](https://t.me/particle_developer_bot) to discuss potential integration.</Note>
  </Accordion>

  <Accordion title="What are the options for chain_name returned by the backend API?" icon="link">
    **Answer:** The `chain_name` values returned by the backend API include `evm_chain` and `solana`. Additionally, for Tron, the `chain_name` is also represented as `evm_chain`.

    These values indicate the blockchain network associated with the account.
  </Accordion>

  <Accordion title="How do I fix webpack 5 polyfills error when creating a new React application?" icon="browser">
    **Answer:** When using `create-react-app` version 5 or above, you might encounter issues due to the lack of NodeJS polyfills, which are no longer included by default. To fix this, you can use `react-app-rewired` and install the necessary polyfill modules.

    * **Step 1:** After creating a new application with `CRA`, install `react-app-rewired` and the required polyfill packages.

      If you're using Yarn:

      ```sh theme={null}
      yarn add --dev react-app-rewired crypto-browserify stream-browserify assert stream-http https-browserify os-browserify url buffer process vm-browserify browserify-zlib
      ```

      If you're using NPM:

      ```sh theme={null}
      npm install --save-dev react-app-rewired crypto-browserify stream-browserify assert stream-http https-browserify os-browserify url buffer process vm-browserify browserify-zlib
      ```

    * **Step 2:** Create a `config-overrides.js` file in the root of your project and add the necessary configuration to include the missing polyfills. This file will override the default Webpack configuration provided by `create-react-app`.

      ```js config-overrides.js theme={null}
      const webpack = require('webpack');

      module.exports = function override(config) {
        const fallback = config.resolve.fallback || {};
        Object.assign(fallback, {
          crypto: require.resolve('crypto-browserify'),
          stream: require.resolve('stream-browserify'),
          assert: require.resolve('assert'),
          http: require.resolve('stream-http'),
          https: require.resolve('https-browserify'),
          os: require.resolve('os-browserify'),
          url: require.resolve('url'),
          zlib: require.resolve('browserify-zlib'),
          process: require.resolve('process/browser'),
        });
        config.resolve.fallback = fallback;
        config.plugins = (config.plugins || []).concat([
          new webpack.ProvidePlugin({
            process: 'process/browser.js',
            Buffer: ['buffer', 'Buffer'],
          }),
        ]);

        config.module.rules = config.module.rules.map((rule) => {
          if (rule.oneOf instanceof Array) {
            rule.oneOf[rule.oneOf.length - 1].exclude = [
              /\.(js|mjs|jsx|cjs|ts|tsx)$/,
              /\.html$/,
              /\.json$/,
            ];
          }
          return rule;
        });

        return config;
      };
      ```

    * **Step 3:** Modify the `scripts` section in your `package.json` to use `react-app-rewired` instead of the default `react-scripts`:

      ```json theme={null}
      "scripts": {
        "start": "react-app-rewired start",
        "build": "react-app-rewired build",
        "test": "react-app-rewired test",
        "eject": "react-scripts eject"
      },
      ```

    After making these changes, your React application should build successfully without encountering NodeJS polyfill errors.
  </Accordion>

  <Accordion title="How do I fix the '__wbindgen_add_to_stack_pointer' error in a React app using Vite?" icon="desktop">
    **Answer:** If you're encountering the error `"Cannot read properties of undefined (reading '__wbindgen_add_to_stack_pointer')"` in your React app using Vite, it likely relates to issues with loading a WebAssembly (Wasm) module.

    To resolve this, you can use the Particle Network WASM plugin with a customized Vite configuration. Here's how to set it up:

    1. **Install the Vite Plugin:** Ensure you have the necessary WASM files and the plugin configured.

    ```sh Terminal theme={null}
    npm i @vitejs/plugin-react
    ```

    2. **Update your `vite.config.ts`:** Add the following configuration to correctly handle the WebAssembly module in development mode:

    ```ts vite.config.ts theme={null}
        import { defineConfig, Plugin, ConfigEnv } from 'vite';
      import react from '@vitejs/plugin-react';
      import fs from 'fs';
      import path from 'path';

      const particleWasmPlugin: Plugin | undefined = {
          name: 'particle-wasm',
          apply: (_, env: ConfigEnv) => {
              return env.mode === 'development';
          },
          buildStart: () => {
              const copiedPath = path.join(
                  __dirname,
                  'node_modules/@particle-network/thresh-sig/wasm/thresh_sig_wasm_bg.wasm'
              );
              const dir = path.join(__dirname, 'node_modules/.vite/wasm');
              const resultPath = path.join(dir, 'thresh_sig_wasm_bg.wasm');
              if (!fs.existsSync(dir)) {
                  fs.mkdirSync(dir, { recursive: true });
              }
              fs.copyFileSync(copiedPath, resultPath);
          },
      };

      export default defineConfig({
        plugins: [react(), particleWasmPlugin],
        server: {
          host: '0.0.0.0',
        },
        define: {
          'process.env': process.env
        },
        build: {
          target: 'esnext', // you can also use 'es2020' here
        },
        optimizeDeps: {
          esbuildOptions: {
            target: 'esnext', // you can also use 'es2020' here
          },
        },
      });
    ```

    This configuration helps ensure that the WebAssembly module is correctly copied and accessible during development, preventing the `__wbindgen_add_to_stack_pointer` error from occurring.
  </Accordion>
</AccordionGroup>

<Note>
  **Still need help?**

  [Open a ticket](https://t.me/particle_developer_bot) with Particle's Developer Relations team through the dedicated Telegram support bot.
</Note>