Spark Wallet Integration Guide

// This is what your wallet should implement
class YourWalletProvider implements ISparkProvider {
  async connect(): Promise<string> {
    // Your wallet's connection logic
    const publicKey = await this.connectToWallet();
    this.isConnected = true;
    return publicKey;
  }

  async disconnect(): Promise<void> {
    await this.disconnectFromWallet();
    this.isConnected = false;
  }

  async getAddress(): Promise<string> {
    return await this.getWalletAddress();
  }

  async signMessage(message: string | SparkSignMessageRequest): Promise<SparkSignatureResult> {
    const messageText = typeof message === 'string' ? message : message.message;
    const isTaproot = typeof message === 'object' ? message.isTaproot : false;
    
    if (isTaproot) {
      const signature = await this.signMessageWithTaproot(messageText);
      return { signature };
    } else {
      const signature = await this.signMessageRegular(messageText);
      return { signature };
    }
  }

  async signMessageWithTaproot(message: string): Promise<SparkSignatureResult> {
    const signature = await this.signMessageWithTaproot(message);
    return { signature };
  }

  async transferBitcoin(params: {
    receiverSparkAddress: string;
    amountSats: bigint;
    isTaproot?: boolean;
  }): Promise<string> {
    return await this.sendBitcoin({
      to: params.receiverSparkAddress,
      amount: params.amountSats,
      useTaproot: params.isTaproot || false
    });
  }

  async transferTokens(params: {
    tokenPublicKey: string;
    receiverSparkAddress: string;
    tokenAmount: number;
    isTaproot?: boolean;
  }): Promise<string> {
    return await this.sendToken({
      tokenPublicKey: params.tokenPublicKey,
      to: params.receiverSparkAddress,
      amount: params.tokenAmount,
      useTaproot: params.isTaproot || false
    });
  }

  async request(method: string, params?: unknown): Promise<unknown> {
    return await this.handleRequest(method, params);
  }

  // Your wallet's internal methods
  private async connectToWallet(): Promise<string> { /* ... */ }
  private async disconnectFromWallet(): Promise<void> { /* ... */ }
  private async getWalletAddress(): Promise<string> { /* ... */ }
  private async signMessageRegular(message: string): Promise<string> { /* ... */ }
  private async sendBitcoin(params: any): Promise<string> { /* ... */ }
  private async sendToken(params: any): Promise<string> { /* ... */ }
  private async handleRequest(method: string, params?: unknown): Promise<unknown> { /* ... */ }
}

import { SparkWalletConnector, type ISparkProvider } from '@dynamic-labs/spark';

export class YourSparkConnector extends SparkWalletConnector {
  /**
   * The name of the wallet connector
   * @override Required override from the base connector class
   */
  override name = 'Your Wallet Name';

  /**
   * Unique identifier for your wallet
   * @override Required override from the base connector class
   */
  override overrideKey = 'yourwallet';

  /**
   * Whether the wallet can connect via custodial service
   * @override Optional override
   */
  override canConnectViaCustodialService = false;

  /**
   * The constructor for the connector, with the relevant metadata
   * @param props The options for the connector
   */
  constructor(props: any) {
    super({
      ...props,
      metadata: {
        id: 'yourwallet',
        name: 'Your Wallet Name',
        icon: 'https://your-wallet.com/icon.png',
      },
    });
  }

  /**
   * Returns the wallet provider instance
   * @override Required override from the base connector class
   */
  public override getProvider(): ISparkProvider | undefined {
    return window.yourWalletProvider;
  }
}