@qhristen/paygrid 0.1.0

package/dist/checkout/index.jsx

@@ -0,0 +1,235 @@
+"use client";
+import { useEffect, useState } from "react";
+import { SUPPORTED_TOKENS } from "../config";
+import { PaymentMethod } from "../types";
+import { initWASM, isWASMSupported, ShadowWireClient, } from "@radr/shadowwire";
+export function CheckoutModal({ amount: propsAmount, method: propsMethod, tokenSymbol: propsTokenSymbol, sender: propsSender, onPaymentResponse, }) {
+    const [isCheckoutOpen, setIsCheckoutOpen] = useState(false);
+    const [step, setStep] = useState("config");
+    const [selectedToken, setSelectedToken] = useState(propsTokenSymbol);
+    const [selectedMethod, setSelectedMethod] = useState(propsMethod === "manual-transfer"
+        ? PaymentMethod.MANUAL_TRANSFER
+        : PaymentMethod.WALLET_SIGNING);
+    const [client] = useState(() => new ShadowWireClient());
+    const [amount, setAmount] = useState(propsAmount);
+    const [activeIntent, setActiveIntent] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const apiKey = process.env.NEXT_PUBLIC_PAYGRID_API_SECRET;
+    const [wasmInitialized, setWasmInitialized] = useState(false);
+    const [balance, setBalance] = useState(null);
+    useEffect(() => {
+        async function init() {
+            if (!isWASMSupported()) {
+                setError("WebAssembly not supported");
+                return;
+            }
+            try {
+                await initWASM("/wasm/settler_wasm_bg.wasm");
+                setWasmInitialized(true);
+                await loadBalance();
+            }
+            catch (err) {
+                setError("Initialization failed: " + err.message);
+            }
+        }
+        init();
+    }, []);
+    const loadBalance = async () => {
+        try {
+            const data = await client.getBalance(propsSender, selectedToken);
+            setBalance(data.available / 1e9);
+        }
+        catch (err) {
+            console.error("Balance load failed:", err);
+        }
+    };
+    const handleStartPayment = async () => {
+        try {
+            setIsLoading(true);
+            setError(null);
+            const headers = {};
+            if (apiKey)
+                headers["x-api-key"] = apiKey;
+            const response = await fetch("/api/paygrid/payment-intents", {
+                method: "POST",
+                headers: {
+                    ...headers,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    amount,
+                    method: propsMethod,
+                    tokenSymbol: selectedToken,
+                    sender: propsSender,
+                }),
+            });
+            // setStep("paying");
+            if (!response.ok) {
+                throw new Error(`Payment intent creation failed: ${response.statusText}`);
+            }
+            const data = (await response.json());
+            if (onPaymentResponse) {
+                onPaymentResponse(data);
+            }
+            setActiveIntent(data);
+            setStep("paying");
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : "An error occurred";
+            setError(errorMessage);
+            console.error("Payment error:", err);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    return (<div>
+      <button onClick={() => setIsCheckoutOpen(true)} className="bg-white/5 hover:bg-white/10 cursor-pointer border border-white/10 text-white px-8 py-4 rounded-2xl font-bold text-lg transition-all">
+        Pay now
+      </button>
+
+      {isCheckoutOpen && (<div className="fixed inset-0 z-50 flex items-center justify-center p-4">
+          <div className="absolute inset-0 bg-black/80 backdrop-blur-sm" onClick={() => setIsCheckoutOpen(false)}></div>
+
+          <div className="relative w-full max-w-md bg-[#111] border border-white/10 rounded-3xl overflow-hidden shadow-2xl">
+            <div className="p-6">
+              <div className="flex justify-between items-center mb-6">
+                <div className="flex items-center gap-2">
+                  <div className="w-6 h-6 bg-indigo-600 rounded flex items-center justify-center text-[10px] font-bold">
+                    P
+                  </div>
+                  <span className="font-bold">PayGrid checkout</span>
+                </div>
+                <button onClick={() => setIsCheckoutOpen(false)} className="text-gray-500 cursor-pointer hover:text-white">
+                  &times;
+                </button>
+              </div>
+
+              {step === "config" && (<div className="space-y-6">
+                  <div>
+                    <label className="text-xs text-gray-500 font-bold uppercase block mb-2">
+                      Select Token
+                    </label>
+                    <div className="grid grid-cols-3 gap-2">
+                      {SUPPORTED_TOKENS.map((token) => (<button key={token.symbol} disabled={token.disabled} onClick={() => setSelectedToken(token.symbol)} className={`p-3 rounded-xl  cursor-pointer border transition-all flex flex-col items-center gap-1 ${selectedToken === token.symbol ? "border-indigo-500 bg-indigo-500/10" : "border-white/5 bg-white/5 hover:border-white/20"}`}>
+                          <div className="w-6 h-6 rounded-full" style={{ backgroundColor: token.color }}></div>
+                          <span className="text-sm font-medium">
+                            {token.symbol}
+                          </span>
+                        </button>))}
+                    </div>
+                  </div>
+
+                  <div>
+                    <label className="text-xs text-gray-500 font-bold uppercase block mb-2">
+                      Payment Method
+                    </label>
+                    <div className="space-y-2">
+                      <button onClick={() => setSelectedMethod(PaymentMethod.WALLET_SIGNING)} className={`w-full p-4  cursor-pointer rounded-xl border text-left flex items-center gap-3 transition-all ${selectedMethod === PaymentMethod.WALLET_SIGNING ? "border-indigo-500 bg-indigo-500/10" : "border-white/5 bg-white/5"}`}>
+                        <div className="p-2 bg-white/5 rounded-lg">⚡</div>
+                        <div>
+                          <p className="text-sm font-semibold">
+                            Wallet Signing
+                          </p>
+                          <p className="text-xs text-gray-500">
+                            Sign with Phantom, Solflare or Backpack
+                          </p>
+                        </div>
+                      </button>
+                      <button onClick={() => setSelectedMethod(PaymentMethod.MANUAL_TRANSFER)} disabled className={`w-full p-4  cursor-pointer rounded-xl border text-left flex items-center gap-3 transition-all ${selectedMethod === PaymentMethod.MANUAL_TRANSFER ? "border-indigo-500 bg-indigo-500/10" : "border-white/5 bg-white/5"}`}>
+                        <div className="p-2 bg-white/5 rounded-lg">📋</div>
+                        <div>
+                          <p className="text-sm font-semibold">
+                            Manual Transfer
+                          </p>
+                          <p className="text-xs text-gray-500">
+                            Send tokens to a unique address
+                          </p>
+                        </div>
+                      </button>
+                    </div>
+                  </div>
+
+                  <div className="pt-4 border-t border-white/10">
+                    <div className="flex justify-between items-end mb-4">
+                      <span className="text-gray-400 text-sm">Total Due</span>
+                      <div className="text-right">
+                        <span className="text-2xl font-bold">
+                          {amount} {selectedToken}
+                        </span>
+                        <p className="text-xs text-gray-500">{`~${amount} ${selectedToken}`}</p>
+                      </div>
+                    </div>
+                    {error && (<div className="bg-red-500/10 border border-red-500/20 p-3 rounded-lg mb-4">
+                        <p className="text-xs text-red-400">{error}</p>
+                      </div>)}
+                    <button onClick={handleStartPayment} disabled={isLoading} className="w-full bg-white text-black py-4 rounded-2xl font-bold hover:bg-gray-200 transition-colors disabled:opacity-50 disabled:cursor-not-allowed">
+                      {isLoading ? "Processing..." : "Confirm & Pay"}
+                    </button>
+                  </div>
+                </div>)}
+
+              {step === "paying" && (<div className="text-center py-8">
+                  <div className="relative w-24 h-24 mx-auto mb-6">
+                    <div className="absolute inset-0 border-4 border-indigo-500/20 rounded-full"></div>
+                    <div className="absolute inset-0 border-4 border-indigo-500 border-t-transparent rounded-full animate-spin"></div>
+                    <div className="absolute inset-0 flex items-center justify-center font-bold text-lg">
+                      {selectedToken}
+                    </div>
+                  </div>
+                  <h3 className="text-xl font-bold mb-2">
+                    Awaiting Transaction
+                  </h3>
+                  <p className="text-gray-500 text-sm mb-6 max-w-[280px] mx-auto">
+                    Please complete the transaction in your wallet. We are
+                    monitoring the Solana network.
+                  </p>
+                  <div className="bg-white/5 border border-white/10 p-4 rounded-2xl font-mono text-xs text-left">
+                    <div className="flex justify-between mb-1">
+                      <span className="text-gray-500">Network</span>
+                      <span>Solana Mainnet</span>
+                    </div>
+                    <div className="flex justify-between mb-1">
+                      <span className="text-gray-500">Status</span>
+                      <span className="text-amber-400">Monitoring...</span>
+                    </div>
+                    <div className="flex justify-between">
+                      <span className="text-gray-500">Intent ID</span>
+                      <span>{activeIntent?.id}</span>
+                    </div>
+                  </div>
+                </div>)}
+
+              {step === "success" && (<div className="text-center py-8">
+                  <div className="w-20 h-20 bg-emerald-500/20 text-emerald-500 rounded-full mx-auto flex items-center justify-center text-4xl mb-6">
+                    ✓
+                  </div>
+                  <h3 className="text-2xl font-bold mb-2">Payment Settled!</h3>
+                  <p className="text-gray-400 text-sm mb-6">
+                    Your transaction has been confirmed on the blockchain.
+                  </p>
+
+                  {/* <div className="space-y-3 text-left">
+                  <div className="bg-white/5 p-4 rounded-2xl border border-white/5">
+                    <p className="text-[10px] text-gray-500 uppercase font-bold mb-1">
+                      Transaction Hash
+                    </p>
+                    <p className="text-xs font-mono text-indigo-400 truncate">
+                      {activeIntent?.transactionSignature}
+                    </p>
+                  </div>
+                </div> */}
+                </div>)}
+            </div>
+
+            <div className="bg-white/5 p-4 text-center">
+              <p className="text-[10px] text-gray-500 font-medium">
+                Powering the decentralized privacy economy with PayGrid
+              </p>
+            </div>
+          </div>
+        </div>)}
+    </div>);
+}
+export default CheckoutModal;

package/dist/client.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./dashboard";
+export * from "./checkout";

package/dist/client.js

@@ -0,0 +1,4 @@
+// Client-side only exports - safe for browser bundling
+export * from "./types";
+export * from "./dashboard";
+export * from "./checkout";

package/dist/config/index.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { PayGridConfig } from '../types';
+export declare const configSchema: z.ZodObject<{
+    SOLANA_RPC_URL: z.ZodString;
+    MERCHANT_WALLET_ADDRESS: z.ZodString;
+    DB_PATH: z.ZodDefault<z.ZodString>;
+    NEXT_PUBLIC_PAYGRID_API_SECRET: z.ZodString;
+    ADMIN_EMAIL: z.ZodString;
+    ADMIN_PASSWORD: z.ZodString;
+    NETWORK: z.ZodDefault<z.ZodEnum<["mainnet-beta", "devnet", "testnet"]>>;
+}, "strip", z.ZodTypeAny, {
+    NEXT_PUBLIC_PAYGRID_API_SECRET: string;
+    SOLANA_RPC_URL: string;
+    MERCHANT_WALLET_ADDRESS: string;
+    DB_PATH: string;
+    ADMIN_EMAIL: string;
+    ADMIN_PASSWORD: string;
+    NETWORK: "mainnet-beta" | "devnet" | "testnet";
+}, {
+    NEXT_PUBLIC_PAYGRID_API_SECRET: string;
+    SOLANA_RPC_URL: string;
+    MERCHANT_WALLET_ADDRESS: string;
+    ADMIN_EMAIL: string;
+    ADMIN_PASSWORD: string;
+    DB_PATH?: string | undefined;
+    NETWORK?: "mainnet-beta" | "devnet" | "testnet" | undefined;
+}>;
+export declare function validateConfig(): PayGridConfig;
+export declare const CONSTANTS: {
+    PAYMENT_EXPIRY_MS: number;
+    CHECK_INTERVAL_MS: number;
+    CONFIRMATIONS_REQUIRED: number;
+};
+export declare const SUPPORTED_TOKENS: {
+    symbol: string;
+    mint: string;
+    color: string;
+    disabled: boolean;
+}[];

package/dist/config/index.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export const configSchema = z.object({
+    SOLANA_RPC_URL: z.string().url(),
+    MERCHANT_WALLET_ADDRESS: z.string().min(44), // Base58 encoded private key
+    DB_PATH: z.string().default('./paygrid.db'),
+    NEXT_PUBLIC_PAYGRID_API_SECRET: z.string().min(32),
+    ADMIN_EMAIL: z.string().email(),
+    ADMIN_PASSWORD: z.string().min(5),
+    NETWORK: z.enum(['mainnet-beta', 'devnet', 'testnet']).default('mainnet-beta'),
+});
+export function validateConfig() {
+    const result = configSchema.safeParse({
+        SOLANA_RPC_URL: process.env.NEXT_PUBLIC_SOLANA_RPC_URL,
+        MERCHANT_WALLET_ADDRESS: process.env.NEXT_PUBLIC_MERCHANT_WALLET_ADDRESS,
+        DB_PATH: process.env.DB_PATH,
+        NEXT_PUBLIC_PAYGRID_API_SECRET: process.env.NEXT_PUBLIC_PAYGRID_API_SECRET,
+        NETWORK: process.env.NEXT_PUBLIC_NETWORK,
+        ADMIN_EMAIL: process.env.NEXT_PUBLIC_ADMIN_EMAIL,
+        ADMIN_PASSWORD: process.env.NEXT_PUBLIC_ADMIN_PASSWORD,
+    });
+    if (!result.success) {
+        console.error('❌ Invalid PayGrid Configuration:', result.error.format());
+        throw new Error(`Invalid PayGrid configuration: ${result.error.message}`);
+    }
+    return {
+        rpcUrl: result.data.SOLANA_RPC_URL,
+        marchantWalletADdress: result.data.MERCHANT_WALLET_ADDRESS,
+        dbPath: result.data.DB_PATH,
+        apiSecret: result.data.NEXT_PUBLIC_PAYGRID_API_SECRET,
+        network: result.data.NETWORK,
+        adminEmail: result.data.ADMIN_EMAIL,
+        adminPassword: result.data.ADMIN_PASSWORD
+    };
+}
+export const CONSTANTS = {
+    PAYMENT_EXPIRY_MS: 30 * 60 * 1000, // 30 minutes
+    CHECK_INTERVAL_MS: 10 * 1000, // 10 seconds
+    CONFIRMATIONS_REQUIRED: 1,
+};
+export const SUPPORTED_TOKENS = [
+    { symbol: 'SOL', mint: '11111111111111111111111111111111', color: '#14F195', disabled: true },
+    { symbol: 'USDC', mint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', color: '#2775CA', disabled: false },
+    { symbol: 'BONK', mint: 'DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263', color: '#FFA500', disabled: true }
+];

package/dist/core/paygrid.d.ts

@@ -0,0 +1,44 @@
+import { AnalyticsData, PayGridConfig, PaymentIntent, TokenSymbol } from "../types";
+import { DepositResponse } from "@radr/shadowwire";
+export declare class PayGrid {
+    private db;
+    private solana;
+    private privacy;
+    private auth;
+    private config;
+    private watcherInterval?;
+    constructor(config: PayGridConfig);
+    init(): Promise<void>;
+    startWatcher(): Promise<void>;
+    stopWatcher(): void;
+    private checkPendingPayments;
+    createPaymentIntent(params: {
+        amount: number;
+        tokenSymbol: TokenSymbol;
+        method: "wallet-signing" | "manual-transfer";
+        sender?: string;
+        metadata?: Record<string, any>;
+    }): Promise<PaymentIntent & {
+        depositResponse: DepositResponse;
+    }>;
+    getPayment(id: string): Promise<PaymentIntent | undefined>;
+    createApiKey(name: string): Promise<{
+        key: string;
+        apiKey: import("../types").ApiKey;
+    }>;
+    validateApiKey(rawKey: string): Promise<boolean>;
+    listApiKeys(): Promise<import("../types").ApiKey[]>;
+    deleteApiKey(id: string): Promise<void>;
+    getPayments(): Promise<PaymentIntent[]>;
+    getAnalytics(days?: number): Promise<AnalyticsData>;
+    withdrawFromPrivacy(params: {
+        tokenSymbol: TokenSymbol;
+        recipient: string;
+    }): Promise<import("@radr/shadowwire").WithdrawResponse | undefined>;
+    transferFromPrivacy(params: {
+        tokenSymbol: TokenSymbol;
+        sender: string;
+        amount: number;
+    }): Promise<void>;
+}
+export declare function initPayGrid(config?: Partial<PayGridConfig>): Promise<PayGrid>;

package/dist/core/paygrid.js

@@ -0,0 +1,238 @@
+import crypto from "crypto";
+import { AuthService } from "../auth";
+import { SolanaService } from "../blockchain";
+import { CONSTANTS, SUPPORTED_TOKENS, validateConfig } from "../config";
+import { PayGridDB } from "../db";
+import { PaymentMethod, PaymentStatus, TokenSymbol, } from "../types";
+import { PrivacyWrapper } from "./privacy-wrapper";
+export class PayGrid {
+    constructor(config) {
+        this.config = config;
+        this.db = new PayGridDB(this.config.dbPath);
+        this.solana = new SolanaService(this.config.rpcUrl);
+        // Initialize Privacy Wrapper
+        this.privacy = new PrivacyWrapper(this.config);
+        this.auth = new AuthService(this.config.apiSecret);
+    }
+    async init() {
+        await this.db.init();
+    }
+    async startWatcher() {
+        console.log("🚀 PayGrid Watcher started");
+        // Run immediately once
+        await this.checkPendingPayments();
+        this.watcherInterval = setInterval(async () => {
+            try {
+                await this.checkPendingPayments();
+            }
+            catch (error) {
+                console.error("PayGrid Watcher Error:", error);
+            }
+        }, CONSTANTS.CHECK_INTERVAL_MS);
+    }
+    stopWatcher() {
+        if (this.watcherInterval) {
+            clearInterval(this.watcherInterval);
+        }
+    }
+    async checkPendingPayments() {
+        const pending = await this.db.getPendingPayments();
+        const now = Date.now();
+        for (const payment of pending) {
+            if (payment.expiresAt < now) {
+                await this.db.updatePaymentStatus(payment.id, "expired");
+                continue;
+            }
+            if (payment.method === PaymentMethod.MANUAL_TRANSFER &&
+                payment.walletAddress) {
+                const signature = await this.solana.findTransferTo(payment.walletAddress, payment.amount);
+                if (signature) {
+                    await this.db.updatePaymentStatus(payment.id, "settled", signature);
+                }
+            }
+            else if (payment.status === "pending_confirmation" &&
+                payment.transactionSignature) {
+                const confirmed = await this.solana.confirmTransaction(payment.transactionSignature);
+                if (confirmed) {
+                    await this.db.updatePaymentStatus(payment.id, "settled");
+                }
+            }
+        }
+    }
+    async createPaymentIntent(params) {
+        try {
+            const id = crypto.randomUUID();
+            // Resolve token mint if symbol is provided
+            let mintAddress;
+            let symbol = params.tokenSymbol;
+            if (params.tokenSymbol === TokenSymbol.SOL) {
+                mintAddress = SUPPORTED_TOKENS.find((t) => t.symbol === TokenSymbol.SOL)?.mint;
+            }
+            else if (params.tokenSymbol === TokenSymbol.USDC) {
+                mintAddress = SUPPORTED_TOKENS.find((t) => t.symbol === TokenSymbol.USDC)?.mint;
+            }
+            else if (params.tokenSymbol === TokenSymbol.BONK) {
+                mintAddress = SUPPORTED_TOKENS.find((t) => t.symbol === TokenSymbol.BONK)?.mint;
+            }
+            let response;
+            if (params.method === "wallet-signing") {
+                try {
+                    const result = await this.privacy.createDepositTransaction({
+                        amount: params.amount,
+                        tokenMint: mintAddress ?? "",
+                        symbol: params.tokenSymbol,
+                        walletAddress: params.sender ?? "",
+                    });
+                    response = result;
+                }
+                catch (e) {
+                    console.error("Failed to create privacy transaction", e);
+                    throw new Error("Failed to create privacy transaction: " + e.message);
+                }
+            }
+            const amount = symbol === TokenSymbol.SOL
+                ? (response?.amount ?? 0) / 1e9
+                : (response?.amount ?? 0) / 1e6;
+            const payment = {
+                id,
+                amount: params.method === "wallet-signing" ? amount : params.amount,
+                tokenMint: mintAddress?.toString() ?? "",
+                tokenSymbol: symbol,
+                method: params.method,
+                status: PaymentStatus.AWAITING_PAYMENT,
+                walletAddress: this.config.marchantWalletADdress,
+                destination: this.config.marchantWalletADdress,
+                sender: params.sender,
+                expiresAt: Date.now() + CONSTANTS.PAYMENT_EXPIRY_MS,
+                createdAt: Date.now(),
+                metadata: params.metadata,
+            };
+            await this.db.createPayment(payment);
+            return { ...payment, depositResponse: response };
+        }
+        catch (error) {
+            console.error("Error creating payment intent:", error);
+            throw error;
+        }
+    }
+    async getPayment(id) {
+        return await this.db.getPayment(id);
+    }
+    async createApiKey(name) {
+        const { key, apiKey } = this.auth.generateApiKey(name);
+        await this.db.createApiKey(apiKey);
+        return { key, apiKey };
+    }
+    async validateApiKey(rawKey) {
+        const keys = await this.db.listApiKeys();
+        for (const key of keys) {
+            if (this.auth.verifyApiKey(rawKey, key.hashedKey)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async listApiKeys() {
+        return await this.db.listApiKeys();
+    }
+    async deleteApiKey(id) {
+        return await this.db.deleteApiKey(id);
+    }
+    async getPayments() {
+        return await this.db.getAllPayments();
+    }
+    async getAnalytics(days = 30) {
+        const payments = await this.db.getAllPayments();
+        const now = Date.now();
+        const startTime = now - days * 24 * 60 * 60 * 1000;
+        const settled = payments.filter((p) => p.status === "settled");
+        // Current period metrics
+        const filteredSettled = settled.filter((p) => p.createdAt >= startTime);
+        const totalRevenue = filteredSettled.reduce((sum, p) => sum + p.amount, 0);
+        // Previous period metrics
+        const prevStartTime = startTime - days * 24 * 60 * 60 * 1000;
+        const prevPeriodSettled = settled.filter((p) => p.createdAt >= prevStartTime && p.createdAt < startTime);
+        const pastRevenue = prevPeriodSettled.reduce((sum, p) => sum + p.amount, 0);
+        let revenueGrowth = 0;
+        if (pastRevenue > 0) {
+            revenueGrowth = ((totalRevenue - pastRevenue) / pastRevenue) * 100;
+        }
+        else if (totalRevenue > 0) {
+            revenueGrowth = 100;
+        }
+        // Group by date for history
+        const historyMap = new Map();
+        // Initialize map with all dates in the range to ensure zero values are shown
+        for (let i = days - 1; i >= 0; i--) {
+            const d = new Date(now - i * 24 * 60 * 60 * 1000);
+            const dateStr = d.toLocaleDateString("en-US", {
+                month: "short",
+                day: "numeric",
+            });
+            historyMap.set(dateStr, 0);
+        }
+        filteredSettled.forEach((p) => {
+            const date = new Date(p.createdAt).toLocaleDateString("en-US", {
+                month: "short",
+                day: "numeric",
+            });
+            if (historyMap.has(date)) {
+                historyMap.set(date, (historyMap.get(date) || 0) + p.amount);
+            }
+        });
+        const history = Array.from(historyMap.entries()).map(([date, amount]) => ({
+            date,
+            amount,
+        }));
+        // Filter all payments for the period for transactionCount and settlementRate calculations
+        const filteredPayments = payments.filter((p) => p.createdAt >= startTime);
+        const filteredSettledCount = filteredPayments.filter((p) => p.status === "settled").length;
+        return {
+            totalRevenue,
+            revenueGrowth,
+            pastRevenue,
+            transactionCount: filteredPayments.length,
+            settlementRate: filteredPayments.length > 0
+                ? (filteredSettledCount / filteredPayments.length) * 100
+                : 0,
+            history,
+        };
+    }
+    // Withdraw funds from the privacy pool to a recipient
+    async withdrawFromPrivacy(params) {
+        try {
+            const res = await this.privacy.withdraw({
+                recipient: params.recipient,
+                symbol: params.tokenSymbol,
+            });
+            console.log(res, "withdrawal response");
+            return res;
+        }
+        catch (error) {
+            console.error("Error withdrawing from privacy:", error);
+            throw error;
+        }
+    }
+    async transferFromPrivacy(params) {
+        try {
+            const res = await this.privacy.transfer({
+                symbol: params.tokenSymbol,
+                amount: params.amount,
+                sender: params.sender
+            });
+        }
+        catch (error) {
+            console.error("Error withdrawing from privacy:", error);
+            throw error;
+        }
+    }
+}
+export async function initPayGrid(config) {
+    const fullConfig = config
+        ? { ...validateConfig(), ...config }
+        : validateConfig();
+    const paygrid = new PayGrid(fullConfig);
+    await paygrid.init();
+    await paygrid.startWatcher();
+    return paygrid;
+}

package/dist/core/privacy-wrapper.d.ts

@@ -0,0 +1,29 @@
+import { PayGridConfig } from "../types";
+import { DepositResponse, TokenSymbol, TransferResponse } from "@radr/shadowwire";
+export declare class PrivacyWrapper {
+    private client;
+    private rpcUrl;
+    private config;
+    constructor(config: PayGridConfig);
+    getPrivateBalance(walletAddress: string, symbol: TokenSymbol): Promise<import("@radr/shadowwire").PoolBalance>;
+    withdraw({ symbol, recipient }: {
+        symbol: string;
+        recipient: string;
+    }): Promise<import("@radr/shadowwire").WithdrawResponse | undefined>;
+    transfer({ symbol, sender, amount, }: {
+        symbol: string;
+        sender: string;
+        amount: number;
+    }): Promise<TransferResponse>;
+    createTransferTransaction(params: {
+        amount: number;
+        walletAddress: string;
+        symbol: TokenSymbol;
+    }): Promise<TransferResponse>;
+    createDepositTransaction(params: {
+        amount: number;
+        walletAddress: string;
+        tokenMint: string;
+        symbol: string;
+    }): Promise<DepositResponse>;
+}