@settlr/sdk 0.4.4 → 0.6.1

package/dist/index.js

@@ -32,23 +32,40 @@ var index_exports = {};
 __export(index_exports, {
   BuyButton: () => BuyButton,
   CheckoutWidget: () => CheckoutWidget,
+  INCO_LIGHTNING_PROGRAM_ID: () => INCO_LIGHTNING_PROGRAM_ID,
+  OneClickClient: () => OneClickClient,
   PaymentModal: () => PaymentModal,
+  PrivacyFeatures: () => PrivacyFeatures,
+  REACT_NATIVE_EXAMPLE: () => REACT_NATIVE_EXAMPLE,
+  REST_API: () => REST_API,
   SETTLR_CHECKOUT_URL: () => SETTLR_CHECKOUT_URL,
+  SETTLR_PROGRAM_ID: () => SETTLR_PROGRAM_ID,
   SUPPORTED_NETWORKS: () => SUPPORTED_NETWORKS,
   SUPPORTED_TOKENS: () => SUPPORTED_TOKENS,
   Settlr: () => Settlr,
   SettlrProvider: () => SettlrProvider,
+  UNITY_EXAMPLE: () => UNITY_EXAMPLE,
   USDC_MINT_DEVNET: () => USDC_MINT_DEVNET,
   USDC_MINT_MAINNET: () => USDC_MINT_MAINNET,
   USDT_MINT_DEVNET: () => USDT_MINT_DEVNET,
   USDT_MINT_MAINNET: () => USDT_MINT_MAINNET,
+  buildAllowanceRemainingAccounts: () => buildAllowanceRemainingAccounts,
+  buildPrivateReceiptAccounts: () => buildPrivateReceiptAccounts,
+  createOneClickClient: () => createOneClickClient,
   createWebhookHandler: () => createWebhookHandler,
+  encryptAmount: () => encryptAmount,
+  findAllowancePda: () => findAllowancePda,
+  findPrivateReceiptPda: () => findPrivateReceiptPda,
   formatUSDC: () => formatUSDC,
+  generateCheckoutUrl: () => generateCheckoutUrl,
+  generateDeepLinkCheckout: () => generateDeepLinkCheckout,
   getTokenDecimals: () => getTokenDecimals,
   getTokenMint: () => getTokenMint,
+  parseCallbackUrl: () => parseCallbackUrl,
   parseUSDC: () => parseUSDC,
   parseWebhookPayload: () => parseWebhookPayload,
   shortenAddress: () => shortenAddress,
+  simulateAndGetHandle: () => simulateAndGetHandle,
   usePaymentLink: () => usePaymentLink,
   usePaymentModal: () => usePaymentModal,
   useSettlr: () => useSettlr,
@@ -1219,27 +1236,401 @@ function createWebhookHandler(options) {
     }
   };
 }
+
+// src/privacy.ts
+var import_web33 = require("@solana/web3.js");
+var INCO_LIGHTNING_PROGRAM_ID = new import_web33.PublicKey(
+  "5sjEbPiqgZrYwR31ahR6Uk9wf5awoX61YGg7jExQSwaj"
+);
+var SETTLR_PROGRAM_ID = new import_web33.PublicKey(
+  "339A4zncMj8fbM2zvEopYXu6TZqRieJKebDiXCKwquA5"
+);
+function findAllowancePda(handle, allowedAddress) {
+  const handleBuffer = Buffer.alloc(16);
+  let h = handle;
+  for (let i = 0; i < 16; i++) {
+    handleBuffer[i] = Number(h & BigInt(255));
+    h = h >> BigInt(8);
+  }
+  return import_web33.PublicKey.findProgramAddressSync(
+    [handleBuffer, allowedAddress.toBuffer()],
+    INCO_LIGHTNING_PROGRAM_ID
+  );
+}
+function findPrivateReceiptPda(paymentId) {
+  return import_web33.PublicKey.findProgramAddressSync(
+    [Buffer.from("private_receipt"), Buffer.from(paymentId)],
+    SETTLR_PROGRAM_ID
+  );
+}
+async function encryptAmount(amount) {
+  const buffer = Buffer.alloc(16);
+  let a = amount;
+  for (let i = 0; i < 16; i++) {
+    buffer[i] = Number(a & BigInt(255));
+    a = a >> BigInt(8);
+  }
+  return new Uint8Array(buffer);
+}
+async function buildPrivateReceiptAccounts(config) {
+  const [privateReceiptPda, privateReceiptBump] = findPrivateReceiptPda(config.paymentId);
+  return {
+    customer: config.customer,
+    merchant: config.merchant,
+    privateReceipt: privateReceiptPda,
+    incoLightningProgram: INCO_LIGHTNING_PROGRAM_ID,
+    systemProgram: import_web33.SystemProgram.programId,
+    bump: privateReceiptBump
+  };
+}
+async function simulateAndGetHandle(connection, transaction, privateReceiptPda) {
+  try {
+    const simulation = await connection.simulateTransaction(
+      transaction,
+      void 0,
+      [privateReceiptPda]
+    );
+    if (simulation.value.err) {
+      console.error("Simulation failed:", simulation.value.err);
+      return null;
+    }
+    if (simulation.value.accounts?.[0]?.data) {
+      const data = Buffer.from(simulation.value.accounts[0].data[0], "base64");
+      const paymentIdLen = data.readUInt32LE(8);
+      const handleOffset = 8 + 4 + paymentIdLen + 32 + 32;
+      let handle = BigInt(0);
+      for (let i = 15; i >= 0; i--) {
+        handle = handle * BigInt(256) + BigInt(data[handleOffset + i]);
+      }
+      return handle;
+    }
+    return null;
+  } catch (error) {
+    console.error("Simulation error:", error);
+    return null;
+  }
+}
+function buildAllowanceRemainingAccounts(handle, customer, merchant) {
+  const [customerAllowancePda] = findAllowancePda(handle, customer);
+  const [merchantAllowancePda] = findAllowancePda(handle, merchant);
+  return [
+    { pubkey: customerAllowancePda, isSigner: false, isWritable: true },
+    { pubkey: merchantAllowancePda, isSigner: false, isWritable: true }
+  ];
+}
+var PrivacyFeatures = {
+  /** Amount is FHE-encrypted, only handle stored on-chain */
+  ENCRYPTED_AMOUNTS: true,
+  /** Selective disclosure - only merchant + customer can decrypt */
+  ACCESS_CONTROL: true,
+  /** CSV export still works (decrypts server-side for authorized merchant) */
+  ACCOUNTING_COMPATIBLE: true,
+  /** Inco covalidators ensure trustless decryption */
+  TRUSTLESS_DECRYPTION: true
+};
+var BillingCycles = {
+  /** Weekly (7 days) */
+  WEEKLY: 7 * 24 * 60 * 60,
+  /** Bi-weekly (14 days) */
+  BIWEEKLY: 14 * 24 * 60 * 60,
+  /** Monthly (30 days) */
+  MONTHLY: 30 * 24 * 60 * 60,
+  /** Quarterly (90 days) */
+  QUARTERLY: 90 * 24 * 60 * 60,
+  /** Yearly (365 days) */
+  YEARLY: 365 * 24 * 60 * 60
+};
+
+// src/one-click.ts
+var OneClickClient = class {
+  constructor(baseUrl = "https://settlr.dev") {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  /**
+   * Customer approves a spending limit for a merchant
+   */
+  async approve(options) {
+    const response = await fetch(`${this.baseUrl}/api/one-click`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        action: "approve",
+        ...options
+      })
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      throw new Error(data.error || "Failed to create approval");
+    }
+    return {
+      success: true,
+      approval: data.approval
+    };
+  }
+  /**
+   * Check if customer has active approval for merchant
+   */
+  async check(customerWallet, merchantWallet) {
+    const response = await fetch(`${this.baseUrl}/api/one-click`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        action: "check",
+        customerWallet,
+        merchantWallet
+      })
+    });
+    const data = await response.json();
+    return {
+      hasApproval: data.hasApproval || false,
+      remainingLimit: data.remainingLimit,
+      approval: data.approval
+    };
+  }
+  /**
+   * Merchant charges customer using their one-click approval
+   * No customer interaction required if approval exists with sufficient limit
+   */
+  async charge(options) {
+    const response = await fetch(`${this.baseUrl}/api/one-click`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        action: "charge",
+        ...options
+      })
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      return {
+        success: false,
+        error: data.error
+      };
+    }
+    return {
+      success: true,
+      txSignature: data.txSignature,
+      remainingLimit: data.remainingLimit
+    };
+  }
+  /**
+   * Customer revokes merchant's one-click access
+   */
+  async revoke(customerWallet, merchantWallet) {
+    const response = await fetch(`${this.baseUrl}/api/one-click`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        action: "revoke",
+        customerWallet,
+        merchantWallet
+      })
+    });
+    return { success: response.ok };
+  }
+};
+function createOneClickClient(baseUrl) {
+  return new OneClickClient(baseUrl);
+}
+
+// src/mobile.ts
+function generateCheckoutUrl(options, baseUrl = "https://settlr.dev") {
+  const params = new URLSearchParams();
+  params.set("amount", options.amount.toString());
+  params.set("merchant", options.merchantWallet);
+  if (options.merchantName) params.set("name", options.merchantName);
+  if (options.memo) params.set("memo", options.memo);
+  if (options.successUrl) params.set("success_url", options.successUrl);
+  if (options.cancelUrl) params.set("cancel_url", options.cancelUrl);
+  if (options.orderId) params.set("order_id", options.orderId);
+  if (options.customerId) params.set("customer_id", options.customerId);
+  return `${baseUrl}/checkout?${params.toString()}`;
+}
+function generateDeepLinkCheckout(options, appScheme, baseUrl = "https://settlr.dev") {
+  const orderId = options.orderId || `order_${Date.now()}`;
+  return generateCheckoutUrl({
+    ...options,
+    orderId,
+    successUrl: `${appScheme}://payment-success?order=${orderId}`,
+    cancelUrl: `${appScheme}://payment-cancel?order=${orderId}`
+  }, baseUrl);
+}
+function parseCallbackUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const params = parsed.searchParams;
+    if (parsed.host === "payment-success" || parsed.pathname.includes("success")) {
+      return {
+        success: true,
+        signature: params.get("signature") || void 0,
+        orderId: params.get("order") || params.get("order_id") || void 0
+      };
+    }
+    if (parsed.host === "payment-cancel" || parsed.pathname.includes("cancel")) {
+      return {
+        success: false,
+        orderId: params.get("order") || params.get("order_id") || void 0,
+        error: "Payment cancelled by user"
+      };
+    }
+    return {
+      success: false,
+      error: "Unknown callback URL format"
+    };
+  } catch {
+    return {
+      success: false,
+      error: "Failed to parse callback URL"
+    };
+  }
+}
+var REST_API = {
+  createSession: "/api/checkout/create",
+  checkStatus: "/api/checkout/status",
+  oneClick: "/api/one-click",
+  webhook: "/api/webhooks"
+  // For server-to-server notifications
+};
+var UNITY_EXAMPLE = `
+// SettlrPayment.cs - Drop into your Unity project
+
+using UnityEngine;
+using UnityEngine.Networking;
+using System.Collections;
+
+public class SettlrPayment : MonoBehaviour
+{
+    public string merchantWallet = "YOUR_WALLET_ADDRESS";
+    public string settlrUrl = "https://settlr.dev";
+    
+    // Call this to start a payment
+    public void StartPayment(float amount, string orderId, System.Action<bool, string> callback)
+    {
+        string url = $"{settlrUrl}/checkout?amount={amount}&merchant={merchantWallet}&order_id={orderId}";
+        
+        // Add deep link callback (register mygame:// scheme in your app)
+        url += $"&success_url=mygame://payment-success?order={orderId}";
+        url += $"&cancel_url=mygame://payment-cancel?order={orderId}";
+        
+        Application.OpenURL(url);
+        
+        // Start polling for completion
+        StartCoroutine(PollPaymentStatus(orderId, callback));
+    }
+    
+    IEnumerator PollPaymentStatus(string orderId, System.Action<bool, string> callback)
+    {
+        string statusUrl = $"{settlrUrl}/api/checkout/status?order_id={orderId}";
+        
+        for (int i = 0; i < 60; i++) // Poll for 5 minutes
+        {
+            using (UnityWebRequest request = UnityWebRequest.Get(statusUrl))
+            {
+                yield return request.SendWebRequest();
+                
+                if (request.result == UnityWebRequest.Result.Success)
+                {
+                    var response = JsonUtility.FromJson<PaymentStatusResponse>(request.downloadHandler.text);
+                    
+                    if (response.status == "completed")
+                    {
+                        callback(true, response.signature);
+                        yield break;
+                    }
+                    else if (response.status == "expired" || response.status == "cancelled")
+                    {
+                        callback(false, null);
+                        yield break;
+                    }
+                }
+            }
+            
+            yield return new WaitForSeconds(5f); // Check every 5 seconds
+        }
+        
+        callback(false, "Timeout");
+    }
+    
+    [System.Serializable]
+    class PaymentStatusResponse
+    {
+        public string status;
+        public string signature;
+    }
+}
+`;
+var REACT_NATIVE_EXAMPLE = `
+// SettlrPayment.tsx - React Native component
+
+import { Linking, Alert } from 'react-native';
+import { useEffect } from 'react';
+
+const SETTLR_URL = 'https://settlr.dev';
+const APP_SCHEME = 'mygame';
+
+export function useSettlrPayment(onSuccess: (sig: string) => void) {
+  useEffect(() => {
+    const handleDeepLink = ({ url }: { url: string }) => {
+      if (url.includes('payment-success')) {
+        const sig = new URL(url).searchParams.get('signature');
+        if (sig) onSuccess(sig);
+      }
+    };
+    
+    Linking.addEventListener('url', handleDeepLink);
+    return () => Linking.removeAllListeners('url');
+  }, [onSuccess]);
+  
+  const startPayment = async (amount: number, merchantWallet: string) => {
+    const orderId = \`order_\${Date.now()}\`;
+    const url = \`\${SETTLR_URL}/checkout?amount=\${amount}&merchant=\${merchantWallet}\` +
+      \`&success_url=\${APP_SCHEME}://payment-success?order=\${orderId}\` +
+      \`&cancel_url=\${APP_SCHEME}://payment-cancel?order=\${orderId}\`;
+    
+    await Linking.openURL(url);
+  };
+  
+  return { startPayment };
+}
+`;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BuyButton,
   CheckoutWidget,
+  INCO_LIGHTNING_PROGRAM_ID,
+  OneClickClient,
   PaymentModal,
+  PrivacyFeatures,
+  REACT_NATIVE_EXAMPLE,
+  REST_API,
   SETTLR_CHECKOUT_URL,
+  SETTLR_PROGRAM_ID,
   SUPPORTED_NETWORKS,
   SUPPORTED_TOKENS,
   Settlr,
   SettlrProvider,
+  UNITY_EXAMPLE,
   USDC_MINT_DEVNET,
   USDC_MINT_MAINNET,
   USDT_MINT_DEVNET,
   USDT_MINT_MAINNET,
+  buildAllowanceRemainingAccounts,
+  buildPrivateReceiptAccounts,
+  createOneClickClient,
   createWebhookHandler,
+  encryptAmount,
+  findAllowancePda,
+  findPrivateReceiptPda,
   formatUSDC,
+  generateCheckoutUrl,
+  generateDeepLinkCheckout,
   getTokenDecimals,
   getTokenMint,
+  parseCallbackUrl,
   parseUSDC,
   parseWebhookPayload,
   shortenAddress,
+  simulateAndGetHandle,
   usePaymentLink,
   usePaymentModal,
   useSettlr,