Using chains with Tier 2 and 3 support — Flutter

final wallets = DynamicSDK.instance.wallets.userWallets;

if (!wallets.any((w) => w.chain == 'EVM')) {
  await DynamicSDK.instance.wallets.embedded.createWallet(chain: EmbeddedWalletChain.evm);
}
if (!wallets.any((w) => w.chain == 'SOL')) {
  await DynamicSDK.instance.wallets.embedded.createWallet(chain: EmbeddedWalletChain.sol);
}

dependencies:
  # Cryptography
  pointycastle: ^3.9.1       # secp256k1, SHA-256, SHA-3, Keccak, RIPEMD-160
  hashlib: ^1.19.2           # Blake2b with configurable output size

  # Encoding
  bs58: ^1.0.2               # Base58 encoding (Tron, Ripple, Mavryk, Solana)
  bech32: ^0.2.2             # Bech32 encoding (Cosmos, Cardano)
  convert: ^3.1.1            # Hex encoding/decoding

  # HTTP
  http: ^1.2.2               # HTTP client for RPC calls

flutter pub get

final solWallet = DynamicSDK.instance.wallets.userWallets
    .firstWhere((w) => w.chain == 'SOL');

final signer = DynamicSDK.instance.solana.createSigner(wallet: solWallet);
final signature = await signer.signMessage(message: hexDigest);
// signature is a hex, base64, or base58 string — normalize before use

final evmWallet = DynamicSDK.instance.wallets.userWallets
    .firstWhere((w) => w.chain == 'EVM');

final signature = await DynamicSDK.instance.wallets.signRawMessage(
  walletId: evmWallet.id,
  accountAddress: evmWallet.address,
  message: hexDigest, // 32-byte hex digest, no 0x prefix
);
// Returns hex string — may have 0x prefix, strip if needed

import 'dart:typed_data';
import 'package:bs58/bs58.dart';

String strip0x(String hex) => hex.startsWith('0x') ? hex.substring(2) : hex;

String bytesToHex(Uint8List bytes) =>
    bytes.map((b) => b.toRadixString(16).padLeft(2, '0')).join();

Uint8List hexToBytes(String hex) {
  final clean = strip0x(hex);
  final result = Uint8List(clean.length ~/ 2);
  for (var i = 0; i < clean.length; i += 2) {
    result[i ~/ 2] = int.parse(clean.substring(i, i + 2), radix: 16);
  }
  return result;
}

Uint8List concatBytes(List<Uint8List> arrays) {
  final total = arrays.fold(0, (s, a) => s + a.length);
  final result = Uint8List(total);
  var offset = 0;
  for (final arr in arrays) {
    result.setAll(offset, arr);
    offset += arr.length;
  }
  return result;
}

// Convert Solana base58 address to 32-byte Ed25519 public key
Uint8List solanaAddressToPubkey(String solanaAddress) {
  return Uint8List.fromList(base58.decode(solanaAddress));
}

// Decode an Ed25519 signature from hex (128 chars), base64, or base58
Uint8List decodeSig(String sig) {
  final clean = sig.startsWith('0x') ? sig.substring(2) : sig.trim();
  if (RegExp(r'^[0-9a-fA-F]+$').hasMatch(clean) && clean.length == 128) {
    return hexToBytes(clean);
  }
  try {
    import 'dart:convert';
    final bin = base64.decode(clean);
    if (bin.length == 64) return Uint8List.fromList(bin);
  } catch (_) {}
  return Uint8List.fromList(base58.decode(clean));
}

import 'dart:typed_data';
import 'package:pointycastle/pointycastle.dart';
import 'package:pointycastle/ecc/curves/secp256k1.dart';
import 'package:pointycastle/ecc/ecc_fp.dart' as fp;

/// Recover the compressed secp256k1 public key from an EVM wallet.
/// [recoveryMessage] is chain-specific (e.g. 'COSMOS_PUBKEY_RECOVERY').
/// [signEip191] is a callback that signs via the Dynamic SDK EIP-191 flow.
/// [evmAddress] is used to validate the recovered key matches the wallet.
Future<Uint8List> recoverEvmPublicKey({
  required String recoveryMessage,
  required Future<String> Function(String) signEip191,
  required String evmAddress,
}) async {
  // signEip191 signs: keccak256("\x19Ethereum Signed Message:\n" + len + message)
  final signature = await signEip191(recoveryMessage);

  final prefix = '\x19Ethereum Signed Message:\n${recoveryMessage.length}';
  final combined = concatBytes([
    Uint8List.fromList(prefix.codeUnits),
    Uint8List.fromList(recoveryMessage.codeUnits),
  ]);
  final msgHash = Digest('Keccak/256').process(combined);

  final sigBytes = hexToBytes(strip0x(signature));
  final r = BigInt.parse(bytesToHex(sigBytes.sublist(0, 32)), radix: 16);
  final s = BigInt.parse(bytesToHex(sigBytes.sublist(32, 64)), radix: 16);
  var v = sigBytes[64];
  if (v >= 27) v -= 27;

  final recovered = _ecRecover(msgHash, r, s, v);
  if (recovered == null) throw Exception('Public key recovery failed');

  final xBytes = _bigIntToBytes(recovered.x!.toBigInteger()!, 32);
  final prefix02or03 = recovered.y!.toBigInteger()!.isOdd ? 0x03 : 0x02;
  return Uint8List.fromList([prefix02or03, ...xBytes]);
}