Complete Solana Wallet Delegation

import { Connection, PublicKey, Transaction } from '@solana/web3.js';
import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token';
import bs58 from 'bs58';

async function delegateSolanaWallet(delegationToken: string, amount: string) {
  try {
    // Step 1: Check if Phantom is installed
    const provider = (window as any).solana;
    if (!provider?.isPhantom) {
      throw new Error('Phantom wallet not found');
    }

    // Step 2: Connect wallet
    await provider.connect();
    const walletPublicKey = new PublicKey(provider.publicKey.toString());
    console.log('Connected to wallet:', walletPublicKey.toBase58());

    // Step 3: Setup connection and token accounts
    const connection = new Connection('https://api.mainnet-beta.solana.com');
    const tokenMintAddress = new PublicKey(
      'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v' // USDC mint
    );

    // Get user's token account
    const tokenAccounts = await connection.getParsedTokenAccountsByOwner(
      walletPublicKey,
      { mint: tokenMintAddress }
    );

    if (tokenAccounts.value.length === 0) {
      throw new Error('No USDC token account found');
    }

    const tokenAccountAddress = tokenAccounts.value[0].pubkey;

    // Step 4: Create delegation transaction
    const delegateAddress = new PublicKey('YOUR_PLATFORM_DELEGATE_ADDRESS');
    const amountLamports = parseFloat(amount) * 1_000_000; // USDC has 6 decimals

    const transaction = new Transaction().add(
      Token.createApproveInstruction(
        TOKEN_PROGRAM_ID,
        tokenAccountAddress,
        delegateAddress,
        walletPublicKey,
        [],
        amountLamports
      )
    );

    // Set recent blockhash
    const { blockhash } = await connection.getRecentBlockhash();
    transaction.recentBlockhash = blockhash;
    transaction.feePayer = walletPublicKey;

    // Step 5: Sign and send delegation transaction
    const signedTx = await provider.signTransaction(transaction);
    const txSignature = await connection.sendRawTransaction(
      signedTx.serialize()
    );

    console.log('Delegation transaction sent:', txSignature);

    // Wait for confirmation
    await connection.confirmTransaction(txSignature, 'confirmed');
    console.log('Delegation transaction confirmed');

    // Step 6: Sign message for ownership proof
    const message = `Prove wallet ownership for delegation\nTimestamp: ${Date.now()}\nNonce: ${Math.random().toString(36).substring(7)}`;
    const encodedMessage = new TextEncoder().encode(message);
    const signedMessage = await provider.signMessage(encodedMessage, 'utf8');
    const signature = bs58.encode(signedMessage.signature);

    console.log('Message signed successfully');

    // Step 7: Submit to API
    const response = await fetch(
      'https://dev.api.baanx.com/v1/delegation/solana/post-approval',
      {
        method: 'POST',
        headers: {
          'x-client-key': 'YOUR_PUBLIC_KEY',
          'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          address: walletPublicKey.toBase58(),
          network: 'solana',
          currency: 'usdc',
          amount: amount,
          txHash: txSignature,
          sigHash: signature,
          sigMessage: message,
          token: delegationToken
        })
      }
    );

    const result = await response.json();

    if (response.ok) {
      console.log('Delegation completed successfully!');
      return { success: true, data: result };
    } else {
      console.error('Delegation failed:', result);
      return { success: false, error: result };
    }

  } catch (error) {
    console.error('Error during delegation:', error);
    return { success: false, error: (error as Error).message };
  }
}

// Usage
const result = await delegateSolanaWallet(
  '100a99cf-f4d3-4fa1-9be9-2e9828b20ebc',
  '5000'
);

import { useWallet, useConnection } from '@solana/wallet-adapter-react';
import { Transaction } from '@solana/web3.js';
import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token';
import bs58 from 'bs58';

function DelegationComponent() {
  const { publicKey, signTransaction, signMessage } = useWallet();
  const { connection } = useConnection();

  const handleDelegation = async (delegationToken: string, amount: string) => {
    if (!publicKey || !signTransaction || !signMessage) {
      throw new Error('Wallet not connected');
    }

    try {
      // Get token account
      const tokenMintAddress = new PublicKey(
        'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v' // USDC
      );

      const tokenAccounts = await connection.getParsedTokenAccountsByOwner(
        publicKey,
        { mint: tokenMintAddress }
      );

      const tokenAccountAddress = tokenAccounts.value[0].pubkey;
      const delegateAddress = new PublicKey('YOUR_PLATFORM_DELEGATE_ADDRESS');
      const amountLamports = parseFloat(amount) * 1_000_000;

      // Create and send delegation transaction
      const transaction = new Transaction().add(
        Token.createApproveInstruction(
          TOKEN_PROGRAM_ID,
          tokenAccountAddress,
          delegateAddress,
          publicKey,
          [],
          amountLamports
        )
      );

      const { blockhash } = await connection.getRecentBlockhash();
      transaction.recentBlockhash = blockhash;
      transaction.feePayer = publicKey;

      const signed = await signTransaction(transaction);
      const txSignature = await connection.sendRawTransaction(
        signed.serialize()
      );

      await connection.confirmTransaction(txSignature);

      // Sign ownership message
      const message = `Prove wallet ownership for delegation\nTimestamp: ${Date.now()}`;
      const encodedMessage = new TextEncoder().encode(message);
      const signedMsg = await signMessage(encodedMessage);
      const signature = bs58.encode(signedMsg);

      // Submit to API
      const response = await fetch(
        'https://dev.api.baanx.com/v1/delegation/solana/post-approval',
        {
          method: 'POST',
          headers: {
            'x-client-key': process.env.NEXT_PUBLIC_CLIENT_KEY!,
            'Authorization': `Bearer ${accessToken}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            address: publicKey.toBase58(),
            network: 'solana',
            currency: 'usdc',
            amount: amount,
            txHash: txSignature,
            sigHash: signature,
            sigMessage: message,
            token: delegationToken
          })
        }
      );

      return await response.json();

    } catch (error) {
      console.error('Delegation error:', error);
      throw error;
    }
  };

  return (
    <button onClick={() => handleDelegation(token, '5000')}>
      Delegate Wallet
    </button>
  );
}

curl --request GET \
  --url 'https://dev.api.baanx.com/v1/wallet/external' \
  --header 'x-client-key: YOUR_PUBLIC_KEY' \
  --header 'Authorization: Bearer YOUR_ACCESS_TOKEN'

[
  {
    "id": 552,
    "address": "DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK",
    "currency": "usdc",
    "balance": "5000.00",
    "allowance": "5000",
    "network": "solana",
    "priority": 1
  }
]