Beta Testing Guide

Developer guide for testing Dynamic’s TSS-MPC implementation

Beta Testing: TSS-MPC Embedded Wallets

The TSS-MPC implementation is currently in beta testing. We may introduce significant changes that could impact wallet functionality. Do not store any assets you cannot afford to lose.

Overview

This beta version of Dynamic TSS-MPC supports 2/2 and 2/3 threshold signature schemes. This guide works for both React and React Native implementations. Server wallets are accessible through our node SDKs. Headless documentation will be provided in future updates.

Future releases will provide additional key share storage flexibility, including independent hosting of backup shares.

Server Wallets Overview

Spin up millions of secure, server-controlled wallets with battle-tested MPC infrastructure. Built for onchain automation, Dynamic Server Wallets let you trigger transactions, interact with contracts, and run complex flows—all without user involvement, and fully owned by your backend.

Server wallets set up steps

Supported Chains

• EVM
• Solana (SVM)

Breaking changes may occur in future updates.

Known Limitations

The following features are currently not supported but will be included in subsequent releases:

1. Importing an exported Solana Private key to a popular Solana Wallet
   • Private key exports will not be in a format compatible with Phantom Wallet or other wallets adhering to the ED25519 standard.
2. Account Abstraction & Gas Sponsorship
3. Global Wallets
4. Low-Level Access to Signers for chains other than EVM and SVM
5. Pre-Generated wallets
6. Google Auth backup share

Additional Functions & Headless Setups

Documentation for headless implementations and advanced functions (including key refreshing, passcodes, backup share Google auth) will be added in the near future.

Getting Started

1. Create a New Environment ID

Do not mix this environment with an existing environment containing V2 or V1 wallets.

2. Request Feature Access

Share your Environment ID with the Dynamic team to enable TSS-MPC via a feature flag.

3. Enable Embedded Wallets V3

Navigate to the Dynamic Dashboard > Developers, Enabled Embedded Wallets and set the default wallet version to V3.

4. Set up your SDK

React and React Native Set Up

reference example: https://github.com/dynamic-labs/mpc-react-demo

1. Install Wallet Connectors

npm i @dynamic-labs/waas-evm
npm i @dynamic-labs/waas-svm

2. Configure Your Provider

Include the connectors inside your provider settings:

import { DynamicWaasEVMConnectors } from "@dynamic-labs/waas-evm";

import { DynamicWaasSVMConnectors } from "@dynamic-labs/waas-svm";


const connectors: [
    // include existing connectors
    DynamicWaasEVMConnectors,
    DynamicWaasSVMConnectors,
  ],

const settings = {
  ...existingSettings,
  walletConnectors: connectors,
};

return (
  <DynamicContextProvider
    theme={theme}
    settings={settings}
    enableInstrumentation
  >
    {/* Your app components */}
  </DynamicContextProvider>
);

3. Access the walletClient, and/or signer as you would with Dynamic previously

import { FC, useCallback, useState } from 'react';
import { encodeFunctionData, parseUnits } from 'viem';
import { baseSepolia } from 'viem/chains';
import { useDynamicContext } from '@dynamic-labs/sdk-react-core';
import { isEthereumWallet } from '@dynamic-labs/ethereum-core';

  const { primaryWallet } = useDynamicContext();;

  const handleSubmit = useCallback(
    async (args: TransactionArgs & { action: 'send' | 'approve' }) => {
      if (!primaryWallet || !isEthereumWallet(primaryWallet) || isLoading) {
        return;
      }

      try {
        const provider = await primaryWallet.getWalletClient();

        // Check if we're on Base Sepolia
        const chain = await provider.getChainId();
        if (chain !== baseSepolia.id) {
          setErrorMessage(
            `Please switch to Base Sepolia network (Chain ID: ${baseSepolia.id}). Current chain ID: ${chain}`,
          );
          return;
        }

        const usdcAmount = parseUnits(args.amount, 6); // USDC has 6 decimal places

        const transaction = {
          chain: baseSepolia,
          data: await encodeFunctionData({
            abi: USDC_ABI,
            args: [args.toAddress, usdcAmount],
            functionName: args.action === 'send' ? 'transfer' : 'approve',
          }),
          to: USDC_CONTRACT_ADDRESS as `0x${string}`,
        };

        const hash = await provider.sendTransaction(transaction);
        setTxnHash(hash);
      }
      catch(e: any){
        console.log('error', e)
      }
    },
    [primaryWallet],
  );

Access MPC functionality through the connector directly

import { DynamicWaasEVMConnector } from '@dynamic-labs/waas-evm';

  const provider = await primaryWallet.getWalletClient();
    // DynamicWaasEVMConnector or DynamicWaasSVMConnector
      const waasConnector =
      primaryWallet.connector as DynamicWaasEVMConnector;

    const walletAccount = await waasConnector.createWalletAccount();

    //  get a wallet client for the wallet account by address
    await waasConnector.getWalletClientByAddress({
      accountAddress: walletAccount.accountAddress,
      });
    // export the client keyshares
    await waasConnector.exportClientKeyshares({
      accountAddress: walletAccount.accountAddress,
    });
    // export the private key
    await waasConnector.exportPrivateKey({
    accountAddress: walletAccount.accountAddress,
    });
    // import the private key
    await waasConnector.importPrivateKey({
      chainName: 'EVM',
      privateKey: 'XXXX',
        });

Some MPC functionality is only accessible through the connector waas client

const provider = await primaryWallet.getWalletClient();
    // DynamicWaasEVMConnector or DynamicWaasSVMConnector
    const waasConnector =
      primaryWallet.connector as DynamicWaasEVMConnector;

    const waasWalletClient = waasConnector.getWaasWalletClient();

    const privateKey = await waasWalletClient.offlineExportPrivateKey({
      keyShares: [],
    });

If using Vite please add the following wasmMiddleware to your vite.config.ts file

/// <reference types="vitest" />
import { promises as fs } from "fs";
import path from "path";

import react from "@vitejs/plugin-react";
import { defineConfig } from "vite";
import type { Plugin, Connect } from "vite";

const wasmMiddleware = (): Plugin => ({
  configureServer: (server) => {
    server.middlewares.use(
      async (
        req: Connect.IncomingMessage,
        res: any,
        next: Connect.NextFunction
      ) => {
        if (req.url?.endsWith(".wasm")) {
          // Directly point to the .wasm file within the realm/dist directory
          const wasmPath = path.join(
            process.cwd(),
            "node_modules/@dynamic-labs-wallet/browser/internal/web/generated",
            path.basename(req.url)
          );
          try {
            const wasmFile = await fs.readFile(wasmPath);
            res.setHeader("Content-Type", "application/wasm");
            res.end(wasmFile);
          } catch (error) {
            next();
          }
          return;
        }
        next();
      }
    );
  },
  name: "wasm-middleware",
});

// https://vitejs.dev/config/
export default defineConfig({
  plugins: [react(), wasmMiddleware()],
  define: {
    "process.env": process.env,
  },
});

Server Wallets with Node SDK

reference example: https://github.com/dynamic-labs/mpc-node-server-demo

1. Retrieve your auth token

Navigate to the Dynamic Dashboard and create a new API token.

2. Install desired Node SDKs

npm i @dynamic-labs-wallet/node-evm
npm i @dynamic-labs-wallet/node-svm

3. Create client with authenticateApiToken call. Seperate clients are needed for each chain.

const BASE_API_URL = 'https://app.dynamicauth.com';
const MPC_RELAY_URL = 'relay.dynamic-preprod.xyz';


export const authenticatedEvmClient = async ({
      authToken,
      environmentId,
      baseApiUrl,
      baseMPCRelayApiUrl,
    }: {
      authToken: string;
      environmentId: string;
      baseApiUrl?: string;
      baseMPCRelayApiUrl?: string;
    }) => {
      const client = new DynamicEvmWalletClient({
        authToken,
        environmentId,
        baseApiUrl: BASE_API_URL,
        baseMPCRelayApiUrl: MPC_RELAY_URL,
      });
      await client.authenticateApiToken(authToken);
      return client;
  };

4. Access MPC functionality by creating a new wallet account

  const AUTH_TOKEN = 'your-auth-token';
  const ENVIRONMENT_ID = 'your-environment-id';

  const evmClient = await authenticatedEvmClient({
    authToken: AUTH_TOKEN,
    environmentId: ENVIRONMENT_ID,
  });

  const thresholdSignatureScheme = 'TWO_OF_TWO'; // or 'TWO_OF_THREE'
  const password = 'your-optional-password';
  const onError = (error: Error) => {
    // handle error
    console.error(error);
  };

  const {
    accountAddress,
    rawPublicKey,
    publicKeyHex,
    externalServerKeyShares,
      } = await evmClient.createWalletAccount({
        thresholdSignatureScheme,
        password,
        onError,
      });

You can now use the accountAddress to sign messages, create transactions, and more. You can also back up your externalServerKeyShares to a secure location.

5. Example: Sign a message with the MPC wallet account

  const AUTH_TOKEN = 'your-auth-token';
  const ENVIRONMENT_ID = 'your-environment-id';

  const evmClient = await authenticatedEvmClient({
    authToken: AUTH_TOKEN,
    environmentId: ENVIRONMENT_ID,
  });

  const message = 'Hello, world!';
  const accountAddress = '0x1234567890123456789012345678901234567890';
  const password = 'your-optional-password';

  const serializedSignature = await evmClient.signMessage({
    message,
    accountAddress,
    password,
  });

Key Wallet Functions to Test

Creating and Importing Wallets

createWalletAccount()

Creates a new TSS-MPC wallet account.

importPrivateKey(options)

Imports a private key.

Parameters:

• privateKey: string - The private key to import
• chainName: string - Currently supports ‘EVM’ and ‘SOL’ only
• thresholdSignatureScheme: string - Defaults to ‘TWO_OF_TWO’

Export Functions

exportPrivateKey(options)

Exports the private key for a specific account.

Parameters:

• accountAddress: string - The address of the account to export

exportClientKeyshares(options)

Exports client keyshares for a specific account.

Parameters:

• accountAddress: string - The address of the account to export keyshares for

offlineExportPrivateKey()

Exports a private key in offline mode.

Feedback

We appreciate your feedback on the TSS-MPC beta. When providing feedback, please:

1. Use the tag TSS-MPC Feedback or Question in your communications
2. Create a thread in Slack with the #TSS-MPC-Feedback hashtag