Specialized Wallets

/**
 * Particle wallet adapter with social login integration
 */
class ParticleAdapter extends BaseMessageSignerWalletAdapter {
  name: WalletName<'Particle'>;
  url: string;
  icon: string;
  supportedTransactionVersions: ReadonlySet<'legacy'>;
  
  constructor(config?: ParticleAdapterConfig);
  
  /** Access to underlying ParticleNetwork SDK instance */
  get particle(): ParticleNetwork;
  
  connect(): Promise<void>;
  disconnect(): Promise<void>;
  sendTransaction<T extends Transaction | VersionedTransaction>(
    transaction: T,
    connection: Connection,
    options?: SendTransactionOptions
  ): Promise<TransactionSignature>;
  signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
  signAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]>;
  signMessage(message: Uint8Array): Promise<Uint8Array>;
}

const ParticleName: WalletName<'Particle'>;

interface ParticleAdapterConfig {
  /** ParticleNetwork configuration options */
  config?: ConstructorParameters<typeof ParticleNetwork>[0];
  
  /** Login configuration for social authentication */
  login?: Parameters<SolanaWallet['connect']>[0];
}

import { ParticleAdapter, ParticleName } from "@solana/wallet-adapter-wallets";

const adapter = new ParticleAdapter({
  config: {
    projectId: "your-project-id",
    clientKey: "your-client-key",
    appId: "your-app-id",
    chainName: "solana",
    chainId: 103, // Solana mainnet
  },
  login: {
    loginType: "email", // or 'phone', 'google', 'facebook', etc.
  }
});

await adapter.connect();

// Access Particle SDK directly
const userInfo = await adapter.particle.auth.getUserInfo();
console.log("User:", userInfo);

/**
 * Keystone wallet adapter with QR-code based signing
 */
class KeystoneWalletAdapter extends BaseMessageSignerWalletAdapter {
  name: WalletName<'Keystone'>;
  url: string;
  icon: string;
  supportedTransactionVersions: ReadonlySet<TransactionVersion>;
  
  constructor(config?: KeystoneWalletAdapterConfig);
  
  connect(): Promise<void>;
  disconnect(): Promise<void>;
  sendTransaction<T extends Transaction | VersionedTransaction>(
    transaction: T,
    connection: Connection,
    options?: SendTransactionOptions
  ): Promise<TransactionSignature>;
  signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
  signAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]>;
  signMessage(message: Uint8Array): Promise<Uint8Array>;
}

const KeystoneWalletName: WalletName<'Keystone'>;

interface KeystoneWalletAdapterConfig {}

import { KeystoneWalletAdapter, KeystoneWalletName } from "@solana/wallet-adapter-wallets";

const adapter = new KeystoneWalletAdapter();

// Connect triggers QR code display for wallet connection
await adapter.connect();

// Transaction signing shows QR code for user to scan with Keystone device
const signedTx = await adapter.signTransaction(transaction);

/**
 * Unsafe burner wallet for development and testing with SIWS support
 * WARNING: Not for production use - private keys are stored in memory
 */
class UnsafeBurnerWalletAdapter extends BaseSignInMessageSignerWalletAdapter {
  name: WalletName<'Burner Wallet'>;
  url: string;
  icon: string;
  supportedTransactionVersions: ReadonlySet<TransactionVersion>;
  
  /** No configuration required - generates keypair automatically */
  constructor();
  
  connect(): Promise<void>;
  disconnect(): Promise<void>;
  sendTransaction<T extends Transaction | VersionedTransaction>(
    transaction: T,
    connection: Connection,
    options?: SendTransactionOptions
  ): Promise<TransactionSignature>;
  signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
  signAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]>;
  signMessage(message: Uint8Array): Promise<Uint8Array>;
  
  /** Sign-in with Solana (SIWS) support */
  signIn(input?: SolanaSignInInput): Promise<SolanaSignInOutput>;
}

const UnsafeBurnerWalletName: WalletName<'Burner Wallet'>;

// No configuration interface - constructor takes no parameters

import { UnsafeBurnerWalletAdapter, UnsafeBurnerWalletName } from "@solana/wallet-adapter-wallets";

// No configuration needed - generates random keypair
const adapter = new UnsafeBurnerWalletAdapter();

await adapter.connect();
console.log("Generated address:", adapter.publicKey?.toString());

// Sign-in with Solana
const signInResult = await adapter.signIn({
  domain: "example.com",
  statement: "Sign in to My App"
});

console.log("Signed in:", signInResult.account.address);

/**
 * WalletConnect integration - re-exports from @walletconnect/solana-adapter
 * This is a proxy package that delegates to the external WalletConnect library
 */

// All exports are re-exported from '@walletconnect/solana-adapter'
// Exact API depends on the WalletConnect Solana adapter version

import * as WalletConnect from "@solana/wallet-adapter-wallets";

// Usage depends on WalletConnect Solana adapter implementation
// Refer to @walletconnect/solana-adapter documentation

import { UnsafeBurnerWalletAdapter } from "@solana/wallet-adapter-wallets";

const adapter = new UnsafeBurnerWalletAdapter();
await adapter.connect();

// Create sign-in message
const signInData = await adapter.signIn({
  domain: window.location.host,
  address: adapter.publicKey!.toString(),
  statement: "Welcome to My Solana App!",
  uri: window.location.origin,
  version: "1",
  chainId: "mainnet",
  nonce: generateNonce(),
  issuedAt: new Date().toISOString(),
});

// Verify sign-in (server-side verification recommended)
const message = createSignInMessage(signInData);
const isValid = nacl.sign.detached.verify(
  new TextEncoder().encode(message),
  signInData.signature,
  signInData.account.publicKey
);

import { ParticleAdapter } from "@solana/wallet-adapter-wallets";

const adapter = new ParticleAdapter({
  config: {
    projectId: process.env.PARTICLE_PROJECT_ID,
    clientKey: process.env.PARTICLE_CLIENT_KEY,
    appId: process.env.PARTICLE_APP_ID,
    chainName: "solana",
    chainId: 103,
  },
  login: {
    loginType: "google", // Social login provider
    account: "user@example.com" // Optional pre-fill
  }
});

// Connect triggers social login flow
await adapter.connect();

// Access user information
const userInfo = await adapter.particle.auth.getUserInfo();
console.log("Social login user:", {
  uuid: userInfo.uuid,
  email: userInfo.email,
  name: userInfo.name,
  avatar: userInfo.avatar
});

import { KeystoneWalletAdapter } from "@solana/wallet-adapter-wallets";

const adapter = new KeystoneWalletAdapter();

// Connect shows QR code for pairing
await adapter.connect();

// Signing shows QR code with transaction data
// User scans with Keystone device, signs, and shows result QR code
const signedTransaction = await adapter.signTransaction(transaction);

// Implementation handles QR code display/scanning automatically

import { UnsafeBurnerWalletAdapter } from "@solana/wallet-adapter-wallets";

// Create multiple test wallets
const testWallets = Array.from({ length: 3 }, () => new UnsafeBurnerWalletAdapter());

await Promise.all(testWallets.map(wallet => wallet.connect()));

console.log("Test wallet addresses:", 
  testWallets.map(wallet => wallet.publicKey?.toString())
);

// Use for automated testing, development, demos
// WARNING: Never use in production - keys are not secure

// Production vs development wallet selection
const createWallet = () => {
  if (process.env.NODE_ENV === 'development') {
    return new UnsafeBurnerWalletAdapter();
  }
  
  return new PhantomWalletAdapter();
};

const adapter = createWallet();

// Check for specialized capabilities
const hasSignIn = 'signIn' in adapter; // SIWS support
const hasParticleSDK = 'particle' in adapter; // Social login
const isHardware = adapter instanceof BaseSignerWalletAdapter; // Hardware wallet