Dynamic Integration

Dynamic provides wallet connection, embedded wallets, and multi-chain auth for web3 apps. You can use Dynamic as your auth provider for Privacy Boost, letting users log in through Dynamic’s UI while using Privacy Boost for private transactions.

How It Works

Dynamic authenticates your users and issues JWTs. The SDK can attach the raw Dynamic JWT to Privacy Boost’s login flow directly, and Privacy Boost validates it against Dynamic’s JWKS endpoint using the custom_jwt auth method.

Server-Side Setup

Your app must be configured with the custom_jwt auth method. Contact the Privacy Boost team with:

JWKS URL — Dynamic’s JWKS endpoint for your environment: https://app.dynamic.xyz/api/v0/sdk/<YOUR_ENVIRONMENT_ID>/.well-known/jwks
Issuer — Required expected iss claim: app.dynamic.xyz/<YOUR_ENVIRONMENT_ID>
Audience — Required expected aud claim from your Dynamic access token. This is the token audience, not the environment_id claim.

The backend configuration looks like:

{
  "jwks_url": "https://app.dynamic.xyz/api/v0/sdk/<ENVIRONMENT_ID>/.well-known/jwks",
  "issuer": "app.dynamic.xyz/<ENVIRONMENT_ID>",
  "audience": "<DYNAMIC_TOKEN_AUDIENCE>"
}

Find your Environment ID in the Dynamic Dashboard under Developer > SDK & API Keys. Decode a representative Dynamic access token and configure audience to match its exact aud claim. Do not use the environment_id claim unless your token’s aud is actually the same value.

Client-Side Integration

1. Set Up Dynamic

Follow Dynamic’s React quickstart to set up DynamicContextProvider:

import { DynamicContextProvider } from '@dynamic-labs/sdk-react-core';
import { EthereumWalletConnectors } from '@dynamic-labs/ethereum';

function App() {
  return (
    <DynamicContextProvider
      settings={{
        environmentId: 'your-environment-id',
        walletConnectors: [EthereumWalletConnectors],
      }}
    >
      <YourApp />
    </DynamicContextProvider>
  );
}

2. Configure Privacy Boost for Direct IdP Auth

Browser IdP callbacks are only supported in local key-vault mode. The default browser mode is the isolated iframe vault, which intentionally does not accept host-page token callbacks.

import { PrivacyBoost } from '@sunnyside-io/privacy-boost';

const sdk = new PrivacyBoost({
  serverUrl: 'https://optimism.sepolia.privacyboost.io',
  appId: 'app_abc123xyz',
  keyVault: { mode: 'local' },
});

3. Create an External Token Callback

The callback returns the raw Dynamic auth token. The SDK attaches it to both the /auth/login bootstrap and /auth/token exchange:

import { useDynamicContext } from '@dynamic-labs/sdk-react-core';

function usePrivacyBoostAuth() {
  const { authToken } = useDynamicContext();

  const getExternalToken = async () => {
    if (!authToken) throw new Error('Not logged in to Dynamic');
    return authToken;
  };

  return { getExternalToken };
}

4. Authenticate with Privacy Boost

const { getExternalToken } = usePrivacyBoostAuth();

await sdk.auth.authenticate(adapter, {
  keySource: { type: 'walletDerived' },
  getExternalToken,
});

Optional: Backend Relay Instead

If you prefer to keep all auth exchanges behind your own backend, use tokenProvider instead of getExternalToken. The options are mutually exclusive. Your backend receives the SDK’s login payload, and forwards to Privacy Boost with the Dynamic JWT:

const tokenProvider = async (loginPayload: any) => {
  const dynamicToken = await getExternalToken();
  const res = await fetch('https://your-backend.com/api/privacy-boost/auth', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${dynamicToken}`,
    },
    body: JSON.stringify(loginPayload),
  });
  return await res.json(); // { token, expiresIn }
};

app.post('/api/privacy-boost/auth', async (req, res) => {
  const toPrivacyBoostAuthPayload = (payload: any) => ({
    grant_type: payload.grantType,
    app_id: payload.appId,
    client_id: payload.clientId,
    client_secret: payload.clientSecret,
    mpk: payload.mpk,
    viewauth_signature: payload.viewauthSignature,
    nonce: payload.nonce,
    account_id: payload.accountId,
    account_salt: payload.accountSalt,
    viewing_public_key: payload.viewingPublicKey,
    nullifying_key: payload.nullifyingKey,
    wallet_address: payload.walletAddress,
    auth_pk_x: payload.authPkX,
    auth_pk_y: payload.authPkY,
    auth_expiry: payload.authExpiry,
    auth_signature: payload.authSignature,
  });

  // 1. Extract Dynamic token from Authorization header
  const dynamicToken = req.headers.authorization?.replace('Bearer ', '');
  if (!dynamicToken) return res.status(401).json({ error: 'Missing Dynamic token' });

  // 2. Forward to Privacy Boost with the Dynamic JWT attached
  const pbResponse = await fetch('https://optimism.sepolia.privacyboost.io/auth/token', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      ...toPrivacyBoostAuthPayload(req.body), // SDK camelCase payload -> /auth/token wire payload
      custom_jwt_token: dynamicToken, // Dynamic JWT — validated via JWKS
    }),
  });

  const data = await pbResponse.json();
  res.json({
    token: data.access_token,
    expiresIn: data.expires_in,
  });
});

Using Dynamic’s Wallet Connector

If your users connect wallets through Dynamic, you can use the connected wallet’s provider with the Privacy Boost SDK:

import { useDynamicContext } from '@dynamic-labs/sdk-react-core';

function usePrivacyBoostWithDynamic() {
  const { primaryWallet } = useDynamicContext();

  const getAdapter = async () => {
    if (!primaryWallet) throw new Error('No wallet connected');
    const provider = await primaryWallet.getWalletClient();

    return {
      async connect() {
        const accounts = await provider.request({ method: 'eth_requestAccounts' });
        const chainId = await provider.request({ method: 'eth_chainId' });
        return { address: accounts[0], chainId: parseInt(chainId, 16) };
      },
      async disconnect() {},
      async signMessage(message: string) {
        const accounts = await provider.request({ method: 'eth_accounts' });
        return provider.request({ method: 'personal_sign', params: [message, accounts[0]] });
      },
      async signTypedData(typedData: string) {
        const accounts = await provider.request({ method: 'eth_accounts' });
        return provider.request({ method: 'eth_signTypedData_v4', params: [accounts[0], typedData] });
      },
      async sendTransaction(tx: unknown) {
        return provider.request({ method: 'eth_sendTransaction', params: [tx] });
      },
      async getAddress() {
        const accounts = await provider.request({ method: 'eth_accounts' });
        return accounts[0];
      },
      async getChainId() {
        const chainId = await provider.request({ method: 'eth_chainId' });
        return parseInt(chainId, 16);
      },
    };
  };

  return { getAdapter };
}

Next Steps

Continue with setup:

Key Management — Configure key persistence for returning users
Error Handling — Handle auth and operation errors

Or explore other auth methods:

Custom JWT — For Auth0, Firebase, Supabase, Clerk, or OIDC providers
Privy — For Privy social login and embedded wallets

Quickstart

Setup

SDKs

Dynamic Integration

Dynamic Integration

How It Works

Server-Side Setup

Client-Side Integration

1. Set Up Dynamic

2. Configure Privacy Boost for Direct IdP Auth

3. Create an External Token Callback

4. Authenticate with Privacy Boost

Optional: Backend Relay Instead

Using Dynamic’s Wallet Connector

Next Steps

​Dynamic Integration

​How It Works

​Server-Side Setup

​Client-Side Integration

​1. Set Up Dynamic

​2. Configure Privacy Boost for Direct IdP Auth

​3. Create an External Token Callback

​4. Authenticate with Privacy Boost

​Optional: Backend Relay Instead

​Using Dynamic’s Wallet Connector

​Next Steps

Dynamic Integration

How It Works

Server-Side Setup

Client-Side Integration

1. Set Up Dynamic

2. Configure Privacy Boost for Direct IdP Auth

3. Create an External Token Callback

4. Authenticate with Privacy Boost

Optional: Backend Relay Instead

Using Dynamic’s Wallet Connector

Next Steps