Quasar SaaS Integration

// src/configs/appConfig.ts
import { createDefaultTransports } from '@tuwaio/satellite-evm';
import { createConfig, injected } from '@wagmi/core';
import { mainnet, sepolia, polygon, Chain } from 'viem/chains';
 
export const appConfig = {
  appName: 'TUWA Pulsar & Quasar Integration',
  appDescription: 'Headless multi-chain tracker with secure cloud synchronization',
};
 
// Endpoints for Solana signature status polling
export const solanaRPCUrls = {
  mainnet: 'https://api.mainnet-beta.solana.com',
  devnet: 'https://api.devnet.solana.com',
};
 
// Supported EVM networks
export const appEVMChains = [mainnet, sepolia, polygon] as readonly [Chain, ...Chain[]];
 
// Minimalist Wagmi config containing only the injected connectors
export const wagmiConfig = createConfig({
  connectors: [injected()],
  transports: createDefaultTransports(appEVMChains),
  chains: appEVMChains,
  ssr: true,
});

// src/hooks/usePulsarStore.ts
'use client';
 
import { createBoundedUseStore, createPulsarStore, createTxInMemoryStore } from '@tuwaio/pulsar-core';
import { pulsarEvmAdapter } from '@tuwaio/pulsar-evm';
import { pulsarSolanaAdapter } from '@tuwaio/pulsar-solana';
import { getMiniSessionAuth } from '@tuwaio/quasar-sdk/react';
 
import { syncTransaction, getHistory } from '@/app/actions';
import { wagmiConfig, solanaRPCUrls, appEVMChains, appConfig } from '@/configs/appConfig';
import { TransactionUnion } from '@/transactions';
 
const STORAGE_KEY = 'transactions-tracking-storage-tuwa';
 
// 1. Initialize the primary persistent Pulsar store
export const initialStore = createPulsarStore<TransactionUnion>({
  name: STORAGE_KEY,
  adapter: [pulsarEvmAdapter(wagmiConfig, appEVMChains), pulsarSolanaAdapter({ rpcUrls: solanaRPCUrls })],
  // Pre-verification hook to check authentication before sending to wallet
  beforeTxProcess: async () => {
    await getMiniSessionAuth();
  },
  // Remote synchronization hook (POST to Quasar)
  onRemoteCreate: async (tx) => {
    try {
      const auth = await getMiniSessionAuth();
      await syncTransaction(tx, auth);
    } catch (err) {
      console.error('[Pulsar Store] Remote sync failed:', err);
    }
  },
});
 
export const usePulsarStore = createBoundedUseStore(initialStore);
 
// 2. Initialize the paginated in-memory history store
const pulsarInMemoryStore = createTxInMemoryStore<TransactionUnion>({
  localTransactionsPool: initialStore.getState().transactionsPool,
 
  // Fetch paginated history from Quasar via server action
  getHistory: async ({ page, walletAddress }) => {
    try {
      const auth = await getMiniSessionAuth();
      const history = await getHistory(
        {
          walletAddress,
          page,
          limit: 10,
          appName: appConfig.appName,
        },
        auth,
      );
 
      if (!history) return null;
 
      return {
        ...history,
        docs: history.docs as TransactionUnion[],
      };
    } catch (error) {
      console.error('[Pulsar Store] Failed to fetch history:', error);
      throw error;
    }
  },
 
  // Once history is pulled from Quasar, inject any pending items into local trackers
  onHistoryFetched: async (remoteTxs) => {
    await initialStore.getState().injectExternalPendingTxs(remoteTxs);
  },
});
 
// 3. Keep the pagination store in sync with local transactions pool updates
initialStore.subscribe((state) => pulsarInMemoryStore.getState().syncWithLocalPool(state.transactionsPool));
 
export const usePulsarInMemoryStore = createBoundedUseStore(pulsarInMemoryStore);

// src/app/actions.ts
'use server';
 
import { MiniSessionAuth, Quasar, Transaction, utils } from '@tuwaio/quasar-sdk';
import { appConfig } from '@/configs/appConfig';
 
const quasar = new Quasar({
  baseUrl: process.env.NEXT_PUBLIC_QUASAR_API_URL,
  secretKey: process.env.QUASAR_SDK_SK ?? '',
});
 
/**
 * Synchronizes a client-side transaction with Quasar.
 * Gated by a client-side mini-session signature verification.
 */
export async function syncTransaction(tx: Transaction, authData: MiniSessionAuth) {
  // Validate signature to prevent quota draining
  const isValidSignature = await utils.verifyMiniSession({
    walletAddress: authData.walletAddress,
    signature: authData.signature,
    timestamp: authData.timestamp,
    chainType: authData.chainType,
  });
 
  if (!isValidSignature) {
    throw new Error('Invalid or expired security signature. Access denied.');
  }
 
  try {
    // Send transaction to Quasar Engine for cloud indexing and webhook execution
    await quasar.pulsar.syncCreate(tx, appConfig.appName);
    return { success: true };
  } catch (error) {
    console.error('[Quasar Sync] Failed to register transaction:', error);
    throw error;
  }
}
 
/**
 * Retrieves the organization's transaction history from Quasar.
 */
export async function getHistory(
  params: {
    walletAddress: string;
    page?: number;
    limit?: number;
    chainId?: string;
    status?: string;
    txKey?: string;
    appName?: string;
  },
  authData: MiniSessionAuth,
) {
  const isValidSignature = await utils.verifyMiniSession({
    walletAddress: authData.walletAddress,
    signature: authData.signature,
    timestamp: authData.timestamp,
    chainType: authData.chainType,
  });
 
  if (!isValidSignature) {
    throw new Error('Invalid or expired security signature. Access denied.');
  }
 
  try {
    const history = await quasar.pulsar.getHistory(params);
    return history;
  } catch (error) {
    console.error('[Quasar History] Failed to retrieve history:', error);
    throw error;
  }
}