Adding Custom Networks

# pubspec.yaml
dependencies:
  # Core cryptography (covers most chains)
  pointycastle: ^3.9.1     # secp256k1, SHA-256, SHA-3, Keccak, RIPEMD-160

  # Extended hashing
  hashlib: ^1.19.2         # Blake2b (Cardano, Mavryk, NEAR transactions)

  # Encoding
  bs58: ^1.0.2             # Base58 / base58check (Bitcoin, Tron, XRP, Mavryk, Solana)
  bech32: ^0.2.2           # Bech32 (Cosmos, Cardano)
  convert: ^3.1.1          # Hex utilities

  # Networking
  http: ^1.2.2

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;

// Cache this per session — recovery only needs to happen once
Uint8List? _cachedPubkey;

Future<Uint8List> getEvmCompressedPubkey() async {
  if (_cachedPubkey != null) return _cachedPubkey!;

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

  // Sign EIP-191 prefixed message to get a recoverable signature
  final signature = await DynamicSDK.instance.wallets.signMessage(
    walletId: evmWallet.id,
    accountAddress: evmWallet.address,
    message: recoveryMessage,
  );

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

  // ecrecover → compressed pubkey
  final sigBytes = hexToBytes(strip0x(signature));
  var v = sigBytes[64];
  if (v >= 27) v -= 27;
  _cachedPubkey = _ecRecover(
    msgHash,
    BigInt.parse(bytesToHex(sigBytes.sublist(0, 32)), radix: 16),
    BigInt.parse(bytesToHex(sigBytes.sublist(32, 64)), radix: 16),
    v,
  );
  return _cachedPubkey!;
}

import 'package:bs58/bs58.dart';

Uint8List getSolanaPublicKey() {
  final solWallet = DynamicSDK.instance.wallets.userWallets
      .firstWhere((w) => w.chain == 'SOL');
  return Uint8List.fromList(base58.decode(solWallet.address));
}

Future<String> signWithEvmWallet(Uint8List digest32) async {
  final evmWallet = DynamicSDK.instance.wallets.userWallets
      .firstWhere((w) => w.chain == 'EVM');

  // digest32 must be exactly 32 bytes, passed as hex without 0x
  final signature = await DynamicSDK.instance.wallets.signRawMessage(
    walletId: evmWallet.id,
    accountAddress: evmWallet.address,
    message: bytesToHex(digest32),
  );

  // Returns 65-byte hex (r + s + v) — strip 0x prefix if present
  return strip0x(signature);
}

final _secp256k1N = BigInt.parse(
  'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141',
  radix: 16,
);

BigInt normalizeLowS(BigInt s) {
  final halfN = _secp256k1N >> 1;
  return s > halfN ? _secp256k1N - s : s;
}

Future<Uint8List> signWithSolanaWallet(String hexDigest) async {
  final solWallet = DynamicSDK.instance.wallets.userWallets
      .firstWhere((w) => w.chain == 'SOL');

  final signer = DynamicSDK.instance.solana.createSigner(wallet: solWallet);
  final result = await signer.signMessage(message: hexDigest);

  // The result may be hex, base64, or base58 — normalize:
  return decodeSig(result);
}

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

Uint8List decodeSig(String sig) {
  final clean = sig.startsWith('0x') ? sig.substring(2) : sig.trim();
  if (RegExp(r'^[0-9a-fA-F]{128}$').hasMatch(clean)) return hexToBytes(clean);
  try {
    final bin = base64.decode(clean);
    if (bin.length == 64) return Uint8List.fromList(bin);
  } catch (_) {}
  return Uint8List.fromList(base58.decode(clean));
}

import 'dart:convert';
import 'package:http/http.dart' as http;

Future<Map<String, dynamic>> jsonRpc(
  String url,
  String method,
  dynamic params,
) async {
  final res = await http.post(
    Uri.parse(url),
    headers: {'Content-Type': 'application/json'},
    body: json.encode({'jsonrpc': '2.0', 'id': 1, 'method': method, 'params': params}),
  );
  final data = json.decode(res.body) as Map<String, dynamic>;
  if (data['error'] != null) throw Exception(data['error']['message']);
  return data['result'] as Map<String, dynamic>;
}

import 'dart:typed_data';

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;
}