@settlr/sdk 0.4.4 → 0.6.1

package/dist/index.d.ts

@@ -875,4 +875,382 @@ declare function createWebhookHandler(options: {
     onError?: (error: Error) => void;
 }): (req: any, res: any) => Promise<void>;
 
-export { BuyButton, type BuyButtonProps, CheckoutWidget, type CheckoutWidgetProps, type CreatePaymentOptions, type CreateSubscriptionOptions, type MerchantConfig, type Payment, PaymentModal, type PaymentModalProps, type PaymentResult, type PaymentStatus, SETTLR_CHECKOUT_URL, SUPPORTED_NETWORKS, SUPPORTED_TOKENS, Settlr, type SettlrConfig, SettlrProvider, type Subscription, type SubscriptionInterval, type SubscriptionPlan, type SubscriptionStatus, type SupportedToken, type TransactionOptions, USDC_MINT_DEVNET, USDC_MINT_MAINNET, USDT_MINT_DEVNET, USDT_MINT_MAINNET, type WebhookEventType, type WebhookHandler, type WebhookHandlers, type WebhookPayload, createWebhookHandler, formatUSDC, getTokenDecimals, getTokenMint, parseUSDC, parseWebhookPayload, shortenAddress, usePaymentLink, usePaymentModal, useSettlr, verifyWebhookSignature };
+/**
+ * Inco Lightning Privacy Module
+ *
+ * Helpers for issuing private receipts with FHE-encrypted payment amounts.
+ * Only authorized parties (merchant + customer) can decrypt via Inco covalidators.
+ */
+
+/**
+ * Inco Lightning Program ID (devnet)
+ */
+declare const INCO_LIGHTNING_PROGRAM_ID: PublicKey;
+/**
+ * Settlr Program ID
+ */
+declare const SETTLR_PROGRAM_ID: PublicKey;
+/**
+ * Derive the allowance PDA for a given handle and allowed address
+ * This PDA stores the decryption permission for a specific address
+ *
+ * @param handle - The u128 handle to the encrypted value (as bigint)
+ * @param allowedAddress - The address being granted decryption access
+ * @returns The allowance PDA and bump
+ */
+declare function findAllowancePda(handle: bigint, allowedAddress: PublicKey): [PublicKey, number];
+/**
+ * Derive the private receipt PDA for a given payment ID
+ *
+ * @param paymentId - The payment ID string
+ * @returns The private receipt PDA and bump
+ */
+declare function findPrivateReceiptPda(paymentId: string): [PublicKey, number];
+/**
+ * Encrypt an amount for Inco Lightning
+ *
+ * In production, this would use the Inco encryption API to create
+ * a proper FHE ciphertext. For now, this is a placeholder that
+ * would be replaced with the actual Inco client library.
+ *
+ * @param amount - The amount in USDC lamports (6 decimals)
+ * @returns Encrypted ciphertext as Uint8Array
+ */
+declare function encryptAmount(amount: bigint): Promise<Uint8Array>;
+/**
+ * Configuration for issuing a private receipt
+ */
+interface PrivateReceiptConfig {
+    /** Payment ID (must be unique) */
+    paymentId: string;
+    /** Amount in USDC (will be converted to lamports) */
+    amount: number;
+    /** Customer wallet address (payer and signer) */
+    customer: PublicKey;
+    /** Merchant wallet address (receives decryption access) */
+    merchant: PublicKey;
+    /** Pre-computed encrypted amount ciphertext (optional, will encrypt if not provided) */
+    encryptedAmount?: Uint8Array;
+}
+/**
+ * Build accounts needed for issuing a private receipt
+ *
+ * Note: This returns the accounts structure but the actual transaction
+ * must be built using the Anchor program client with `remainingAccounts`
+ * for the allowance PDAs.
+ *
+ * @param config - Private receipt configuration
+ * @returns Object with all required account addresses
+ */
+declare function buildPrivateReceiptAccounts(config: PrivateReceiptConfig): Promise<{
+    customer: PublicKey;
+    merchant: PublicKey;
+    privateReceipt: PublicKey;
+    incoLightningProgram: PublicKey;
+    systemProgram: PublicKey;
+    bump: number;
+}>;
+/**
+ * Simulate a transaction to get the resulting encrypted handle
+ *
+ * This is needed because we need the handle to derive allowance PDAs,
+ * but the handle is only known after the encryption CPI call.
+ *
+ * Pattern:
+ * 1. Build tx without allowance accounts
+ * 2. Simulate to get the handle from account state
+ * 3. Derive allowance PDAs from handle
+ * 4. Execute real tx with allowance accounts in remainingAccounts
+ *
+ * @param connection - Solana connection
+ * @param transaction - Built transaction without allowance accounts
+ * @param privateReceiptPda - The PDA where encrypted handle will be stored
+ * @returns The encrypted handle as bigint, or null if simulation failed
+ */
+declare function simulateAndGetHandle(connection: any, // Connection type
+transaction: any, // Transaction type  
+privateReceiptPda: PublicKey): Promise<bigint | null>;
+/**
+ * Build remaining accounts array for allowance PDAs
+ *
+ * These must be passed to the instruction after deriving from the handle.
+ * Since we don't know the handle until after simulation, this is called
+ * after simulateAndGetHandle.
+ *
+ * @param handle - The encrypted handle from simulation
+ * @param customer - Customer address (granted access)
+ * @param merchant - Merchant address (granted access)
+ * @returns Array of remaining accounts for the instruction
+ */
+declare function buildAllowanceRemainingAccounts(handle: bigint, customer: PublicKey, merchant: PublicKey): Array<{
+    pubkey: PublicKey;
+    isSigner: boolean;
+    isWritable: boolean;
+}>;
+/**
+ * Full flow example for issuing a private receipt
+ *
+ * @example
+ * ```typescript
+ * import { issuePrivateReceiptFlow } from '@settlr/sdk/privacy';
+ *
+ * const result = await issuePrivateReceiptFlow({
+ *   connection,
+ *   program, // Anchor program instance
+ *   paymentId: 'payment_123',
+ *   amount: 99.99,
+ *   customer: customerWallet.publicKey,
+ *   merchant: merchantPubkey,
+ *   signTransaction: customerWallet.signTransaction,
+ * });
+ *
+ * console.log('Private receipt:', result.signature);
+ * console.log('Handle:', result.handle.toString());
+ * ```
+ */
+interface IssuePrivateReceiptResult {
+    /** Transaction signature */
+    signature: string;
+    /** Encrypted amount handle (u128 as bigint) */
+    handle: bigint;
+    /** Private receipt PDA address */
+    privateReceiptPda: PublicKey;
+}
+/**
+ * Privacy-preserving receipt features
+ *
+ * Key benefits:
+ * - Payment amounts hidden on-chain (only u128 handle visible)
+ * - Merchant can still decrypt for accounting/tax compliance
+ * - Customer can verify their payment privately
+ * - Competitors can't see your revenue on-chain
+ */
+declare const PrivacyFeatures: {
+    /** Amount is FHE-encrypted, only handle stored on-chain */
+    readonly ENCRYPTED_AMOUNTS: true;
+    /** Selective disclosure - only merchant + customer can decrypt */
+    readonly ACCESS_CONTROL: true;
+    /** CSV export still works (decrypts server-side for authorized merchant) */
+    readonly ACCOUNTING_COMPATIBLE: true;
+    /** Inco covalidators ensure trustless decryption */
+    readonly TRUSTLESS_DECRYPTION: true;
+};
+
+/**
+ * One-Click Payments Module
+ *
+ * Enables frictionless repeat payments for returning customers.
+ * Customer approves a spending limit once, merchant can charge without interaction.
+ */
+interface SpendingApproval {
+    id: string;
+    customerWallet: string;
+    customerEmail?: string;
+    merchantWallet: string;
+    spendingLimit: number;
+    amountSpent: number;
+    remainingLimit: number;
+    expiresAt: Date;
+    status: 'active' | 'expired' | 'revoked';
+    createdAt: Date;
+}
+interface ApproveOneClickOptions {
+    /** Customer's wallet address */
+    customerWallet: string;
+    /** Customer's email (optional, for notifications) */
+    customerEmail?: string;
+    /** Merchant's wallet address */
+    merchantWallet: string;
+    /** Maximum USDC amount the merchant can charge */
+    spendingLimit: number;
+    /** Days until approval expires (default: 30) */
+    expiresInDays?: number;
+}
+interface ChargeOneClickOptions {
+    /** Customer's wallet address */
+    customerWallet: string;
+    /** Merchant's wallet address */
+    merchantWallet: string;
+    /** Amount to charge in USDC */
+    amount: number;
+    /** Optional memo for the transaction */
+    memo?: string;
+}
+interface OneClickResult {
+    success: boolean;
+    error?: string;
+    txSignature?: string;
+    remainingLimit?: number;
+}
+/**
+ * One-Click Payment Client
+ *
+ * @example
+ * ```typescript
+ * import { OneClickClient } from '@settlr/sdk';
+ *
+ * const oneClick = new OneClickClient('https://settlr.dev');
+ *
+ * // Customer approves merchant
+ * await oneClick.approve({
+ *   customerWallet: 'Ac52MM...',
+ *   merchantWallet: 'DjLFeM...',
+ *   spendingLimit: 100, // $100 max
+ * });
+ *
+ * // Merchant charges customer later (no interaction needed)
+ * const result = await oneClick.charge({
+ *   customerWallet: 'Ac52MM...',
+ *   merchantWallet: 'DjLFeM...',
+ *   amount: 25,
+ * });
+ * ```
+ */
+declare class OneClickClient {
+    private baseUrl;
+    constructor(baseUrl?: string);
+    /**
+     * Customer approves a spending limit for a merchant
+     */
+    approve(options: ApproveOneClickOptions): Promise<{
+        success: boolean;
+        approval?: SpendingApproval;
+    }>;
+    /**
+     * Check if customer has active approval for merchant
+     */
+    check(customerWallet: string, merchantWallet: string): Promise<{
+        hasApproval: boolean;
+        remainingLimit?: number;
+        approval?: SpendingApproval;
+    }>;
+    /**
+     * Merchant charges customer using their one-click approval
+     * No customer interaction required if approval exists with sufficient limit
+     */
+    charge(options: ChargeOneClickOptions): Promise<OneClickResult>;
+    /**
+     * Customer revokes merchant's one-click access
+     */
+    revoke(customerWallet: string, merchantWallet: string): Promise<{
+        success: boolean;
+    }>;
+}
+/**
+ * Create a one-click payment client
+ *
+ * @param baseUrl - Settlr API base URL (default: https://settlr.dev)
+ */
+declare function createOneClickClient(baseUrl?: string): OneClickClient;
+
+/**
+ * Mobile Game Integration Utilities
+ *
+ * Simple helpers for integrating Settlr payments in mobile games.
+ * Works with Unity, Unreal, native iOS/Android, React Native, etc.
+ *
+ * The simplest integration is URL-based - just open the checkout URL
+ * and listen for the callback.
+ */
+interface MobileCheckoutOptions {
+    /** Amount in USDC */
+    amount: number;
+    /** Merchant wallet address */
+    merchantWallet: string;
+    /** Optional: Merchant display name */
+    merchantName?: string;
+    /** Optional: Payment description */
+    memo?: string;
+    /** URL to redirect after success */
+    successUrl?: string;
+    /** URL to redirect on cancel */
+    cancelUrl?: string;
+    /** Optional: Your order/transaction ID */
+    orderId?: string;
+    /** Optional: Customer ID for one-click */
+    customerId?: string;
+}
+interface MobileCheckoutResult {
+    success: boolean;
+    signature?: string;
+    orderId?: string;
+    error?: string;
+}
+/**
+ * Generate a checkout URL for mobile games
+ *
+ * Usage in Unity (C#):
+ * ```csharp
+ * string url = $"https://settlr.dev/checkout?amount={amount}&merchant={wallet}";
+ * Application.OpenURL(url);
+ * ```
+ *
+ * Usage in Swift:
+ * ```swift
+ * let url = "https://settlr.dev/checkout?amount=\(amount)&merchant=\(wallet)"
+ * UIApplication.shared.open(URL(string: url)!)
+ * ```
+ */
+declare function generateCheckoutUrl(options: MobileCheckoutOptions, baseUrl?: string): string;
+/**
+ * Generate a deep link for mobile app integration
+ *
+ * For apps that register a custom URL scheme (e.g., mygame://)
+ * the success/cancel URLs can redirect back to the app.
+ *
+ * Example:
+ * - successUrl: "mygame://payment-success?order=123"
+ * - cancelUrl: "mygame://payment-cancel?order=123"
+ */
+declare function generateDeepLinkCheckout(options: MobileCheckoutOptions, appScheme: string, baseUrl?: string): string;
+/**
+ * Parse the callback URL when user returns to app
+ *
+ * Usage in Swift:
+ * ```swift
+ * func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
+ *     if url.scheme == "mygame" && url.host == "payment-success" {
+ *         let signature = URLComponents(url: url, resolvingAgainstBaseURL: true)?
+ *             .queryItems?.first(where: { $0.name == "signature" })?.value
+ *         // Handle success
+ *     }
+ * }
+ * ```
+ */
+declare function parseCallbackUrl(url: string): MobileCheckoutResult;
+/**
+ * REST API endpoint info for server-side integration
+ *
+ * Mobile games can use these APIs directly without the SDK:
+ *
+ * 1. Create checkout session:
+ *    POST /api/checkout/create
+ *    { amount, merchantWallet, memo }
+ *    → { sessionId, checkoutUrl }
+ *
+ * 2. Check payment status:
+ *    GET /api/checkout/status?session={sessionId}
+ *    → { status: 'pending' | 'completed' | 'expired', signature? }
+ *
+ * 3. One-click payment (for returning players):
+ *    POST /api/one-click
+ *    { action: 'charge', customerWallet, merchantWallet, amount }
+ *    → { success, signature }
+ */
+declare const REST_API: {
+    createSession: string;
+    checkStatus: string;
+    oneClick: string;
+    webhook: string;
+};
+/**
+ * Example Unity C# integration code
+ * (For documentation purposes)
+ */
+declare const UNITY_EXAMPLE = "\n// SettlrPayment.cs - Drop into your Unity project\n\nusing UnityEngine;\nusing UnityEngine.Networking;\nusing System.Collections;\n\npublic class SettlrPayment : MonoBehaviour\n{\n    public string merchantWallet = \"YOUR_WALLET_ADDRESS\";\n    public string settlrUrl = \"https://settlr.dev\";\n    \n    // Call this to start a payment\n    public void StartPayment(float amount, string orderId, System.Action<bool, string> callback)\n    {\n        string url = $\"{settlrUrl}/checkout?amount={amount}&merchant={merchantWallet}&order_id={orderId}\";\n        \n        // Add deep link callback (register mygame:// scheme in your app)\n        url += $\"&success_url=mygame://payment-success?order={orderId}\";\n        url += $\"&cancel_url=mygame://payment-cancel?order={orderId}\";\n        \n        Application.OpenURL(url);\n        \n        // Start polling for completion\n        StartCoroutine(PollPaymentStatus(orderId, callback));\n    }\n    \n    IEnumerator PollPaymentStatus(string orderId, System.Action<bool, string> callback)\n    {\n        string statusUrl = $\"{settlrUrl}/api/checkout/status?order_id={orderId}\";\n        \n        for (int i = 0; i < 60; i++) // Poll for 5 minutes\n        {\n            using (UnityWebRequest request = UnityWebRequest.Get(statusUrl))\n            {\n                yield return request.SendWebRequest();\n                \n                if (request.result == UnityWebRequest.Result.Success)\n                {\n                    var response = JsonUtility.FromJson<PaymentStatusResponse>(request.downloadHandler.text);\n                    \n                    if (response.status == \"completed\")\n                    {\n                        callback(true, response.signature);\n                        yield break;\n                    }\n                    else if (response.status == \"expired\" || response.status == \"cancelled\")\n                    {\n                        callback(false, null);\n                        yield break;\n                    }\n                }\n            }\n            \n            yield return new WaitForSeconds(5f); // Check every 5 seconds\n        }\n        \n        callback(false, \"Timeout\");\n    }\n    \n    [System.Serializable]\n    class PaymentStatusResponse\n    {\n        public string status;\n        public string signature;\n    }\n}\n";
+/**
+ * Example React Native integration
+ */
+declare const REACT_NATIVE_EXAMPLE = "\n// SettlrPayment.tsx - React Native component\n\nimport { Linking, Alert } from 'react-native';\nimport { useEffect } from 'react';\n\nconst SETTLR_URL = 'https://settlr.dev';\nconst APP_SCHEME = 'mygame';\n\nexport function useSettlrPayment(onSuccess: (sig: string) => void) {\n  useEffect(() => {\n    const handleDeepLink = ({ url }: { url: string }) => {\n      if (url.includes('payment-success')) {\n        const sig = new URL(url).searchParams.get('signature');\n        if (sig) onSuccess(sig);\n      }\n    };\n    \n    Linking.addEventListener('url', handleDeepLink);\n    return () => Linking.removeAllListeners('url');\n  }, [onSuccess]);\n  \n  const startPayment = async (amount: number, merchantWallet: string) => {\n    const orderId = `order_${Date.now()}`;\n    const url = `${SETTLR_URL}/checkout?amount=${amount}&merchant=${merchantWallet}` +\n      `&success_url=${APP_SCHEME}://payment-success?order=${orderId}` +\n      `&cancel_url=${APP_SCHEME}://payment-cancel?order=${orderId}`;\n    \n    await Linking.openURL(url);\n  };\n  \n  return { startPayment };\n}\n";
+
+export { type ApproveOneClickOptions, BuyButton, type BuyButtonProps, type ChargeOneClickOptions, CheckoutWidget, type CheckoutWidgetProps, type CreatePaymentOptions, type CreateSubscriptionOptions, INCO_LIGHTNING_PROGRAM_ID, type IssuePrivateReceiptResult, type MerchantConfig, type MobileCheckoutOptions, type MobileCheckoutResult, OneClickClient, type OneClickResult, type Payment, PaymentModal, type PaymentModalProps, type PaymentResult, type PaymentStatus, PrivacyFeatures, type PrivateReceiptConfig, REACT_NATIVE_EXAMPLE, REST_API, SETTLR_CHECKOUT_URL, SETTLR_PROGRAM_ID, SUPPORTED_NETWORKS, SUPPORTED_TOKENS, Settlr, type SettlrConfig, SettlrProvider, type SpendingApproval, type Subscription, type SubscriptionInterval, type SubscriptionPlan, type SubscriptionStatus, type SupportedToken, type TransactionOptions, UNITY_EXAMPLE, USDC_MINT_DEVNET, USDC_MINT_MAINNET, USDT_MINT_DEVNET, USDT_MINT_MAINNET, type WebhookEventType, type WebhookHandler, type WebhookHandlers, type WebhookPayload, buildAllowanceRemainingAccounts, buildPrivateReceiptAccounts, createOneClickClient, createWebhookHandler, encryptAmount, findAllowancePda, findPrivateReceiptPda, formatUSDC, generateCheckoutUrl, generateDeepLinkCheckout, getTokenDecimals, getTokenMint, parseCallbackUrl, parseUSDC, parseWebhookPayload, shortenAddress, simulateAndGetHandle, usePaymentLink, usePaymentModal, useSettlr, verifyWebhookSignature };