torque-checkout 1.1.10 → 2.0.0

package/README.md

@@ -1,42 +1,118 @@
-# torque-checkout
+# Torque Checkout SDK
 
-Official Torque checkout SDK for seamless eCommerce integrations. Generate multi-product checkout links, track orders, and manage customer data with our powerful API.
+> **Official Torque checkout SDK for seamless eCommerce integrations with Next.js**
 
-## Quick Start
+The easiest way to integrate Torque checkout into your Next.js eCommerce application. Accept crypto payments with just a few lines of code.
 
-### Prerequisites
+[![npm version](https://img.shields.io/npm/v/torque-checkout.svg)](https://www.npmjs.com/package/torque-checkout)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-**Before installing the package, you must create your Torque business profile:**
+## ✨ Features
 
-1. **Go to Torque Business Dashboard**: https://torque.fi/business/settings
-2. **Connect your wallet** (MetaMask, WalletConnect, etc.)
-3. **Fill out business information** (name, email, website, etc.)
-4. **Set your payment wallet address** (where you want to receive payments)
-5. **Save your profile** (API key will be generated automatically)
-6. **Get your credentials** from the bottom of the business settings page
+- 🚀 **Lightweight & Fast** - Minimal bundle size, optimized for performance
+- ⚡ **Zero Configuration** - Works out of the box with environment variables
+- 🎯 **TypeScript First** - Full TypeScript support with comprehensive types
+- ⚛️ **React Hooks** - Built-in React hooks for seamless client-side integration
+- 🔧 **Next.js Optimized** - Server-side utilities for App Router and Pages Router
+- 🔒 **Production Ready** - Comprehensive error handling and validation
+- 📦 **Multi-Product Support** - Handle complex carts with multiple items
+- 🔄 **Subscription Support** - Built-in subscription management
 
-### Installation
+## 📦 Installation
 
 ```bash
 npm install torque-checkout
 # or
 yarn add torque-checkout
+# or
+pnpm add torque-checkout
 ```
 
-### Basic Usage
+## 🚀 Quick Start
 
-```typescript
-import { TorqueCheckout } from 'torque-checkout'
+### 1. Get Your API Credentials
 
-const torque = new TorqueCheckout({
-  businessId: 'your_business_id',
-  apiKey: 'your_api_key'
+Before using the SDK, you need to set up your Torque business profile:
+
+1. **Go to [Torque Business Dashboard](https://app.torque.fi/business/settings)**
+2. **Connect your wallet** (MetaMask, WalletConnect, etc.)
+3. **Fill out your business information** (name, email, website, etc.)
+4. **Set your payment wallet address** (where you want to receive payments)
+5. **Save your profile** - Your API key will be generated automatically
+6. **Copy your credentials** from the API Integration section:
+   - Business ID
+   - API Key
+
+### 2. Configure Environment Variables
+
+Create a `.env.local` file in your Next.js project:
+
+```env
+TORQUE_BUSINESS_ID=your_business_id_here
+TORQUE_API_KEY=your_api_key_here
+TORQUE_BASE_URL=https://app.torque.fi  # Optional, defaults to production
+```
+
+### 3. Basic Usage
+
+#### Client-Side (React Component)
+
+```tsx
+'use client'
+
+import { useTorqueCheckout } from 'torque-checkout/react'
+
+export default function CheckoutButton() {
+  const { generateProductCheckout, isLoading } = useTorqueCheckout({
+    autoRedirect: true, // Automatically redirect to checkout
+    onSuccess: (url) => console.log('Checkout URL:', url),
+    onError: (error) => console.error('Error:', error)
+  })
+
+  const handleCheckout = async () => {
+    await generateProductCheckout('prod_123', 1, {
+      email: 'customer@example.com',
+      firstName: 'John',
+      lastName: 'Doe'
+    })
+  }
+
+  return (
+    <button onClick={handleCheckout} disabled={isLoading}>
+      {isLoading ? 'Loading...' : 'Checkout'}
+    </button>
+  )
+}
+```
+
+#### Server-Side (API Route)
+
+```ts
+// app/api/checkout/route.ts
+import { handleCheckoutRequest } from 'torque-checkout/nextjs'
+
+export const POST = handleCheckoutRequest({
+  onSuccess: async (url, cart) => {
+    // Optional: Log checkout generation
+    console.log('Checkout generated:', url)
+  }
 })
+```
+
+#### Direct SDK Usage
 
-// Generate cart checkout link
+```ts
+import { createTorqueCheckout } from 'torque-checkout'
+
+const torque = createTorqueCheckout({
+  businessId: process.env.TORQUE_BUSINESS_ID!,
+  apiKey: process.env.TORQUE_API_KEY!
+})
+
+// Generate checkout URL
 const checkoutUrl = await torque.generateCartCheckoutUrl({
   items: [
-    { productId: 'prod_123', quantity: 2, variant: 'large' },
+    { productId: 'prod_123', quantity: 2 },
     { productId: 'prod_456', quantity: 1 }
   ],
   customer: {
@@ -46,48 +122,40 @@ const checkoutUrl = await torque.generateCartCheckoutUrl({
   }
 })
 
-// Redirect customer to checkout
+// Redirect customer
 window.location.href = checkoutUrl
-
-// The generated URL will look like:
-// https://torque.fi/checkout/{businessId}/cart?items={encoded_cart_data}
 ```
 
-## URL Structure
-
-The SDK generates checkout URLs in this format:
+## 📚 Documentation
 
-- **Single Product**: `https://torque.fi/checkout/{businessId}/{productId}?quantity=1`
-- **Multi-Product Cart**: `https://torque.fi/checkout/{businessId}/cart?items={encoded_cart_data}`
+### Core SDK
 
-The `items` parameter contains URL-encoded JSON with your cart data.
+#### `TorqueCheckout` Class
 
-## API Reference
+The main SDK class for generating checkout URLs and managing orders.
 
-### Constructor
+```ts
+import { createTorqueCheckout } from 'torque-checkout'
 
-```typescript
-new TorqueCheckout(config: TorqueConfig)
+const torque = createTorqueCheckout({
+  businessId: 'your_business_id',
+  apiKey: 'your_api_key',
+  baseUrl: 'https://app.torque.fi', // Optional
+  timeout: 30000 // Optional, default: 30000ms
+})
 ```
 
-**Config Options:**
-- `businessId` (required): Your Torque business ID (get from business dashboard)
-- `apiKey` (required): Your API authentication key (get from business dashboard)
-- `timeout` (optional): Request timeout in milliseconds (defaults to 30000)
-
-**Important:** Your `businessId` and `apiKey` are generated when you create your business profile in the Torque dashboard. Make sure you've set your payment wallet address in the business settings before using the SDK.
+#### Methods
 
-### Methods
-
-#### `generateCartCheckoutUrl(cart: CartData): Promise<string>`
+##### `generateCartCheckoutUrl(cart: CartData): Promise<string>`
 
 Generate a checkout URL for a multi-product cart.
 
-```typescript
-const checkoutUrl = await torque.generateCartCheckoutUrl({
+```ts
+const url = await torque.generateCartCheckoutUrl({
   items: [
-    { productId: 'prod_123', quantity: 2, variant: 'large' },
-    { productId: 'prod_456', quantity: 1 }
+    { productId: 'prod_123', quantity: 2, price: 29.99 },
+    { productId: 'prod_456', quantity: 1, price: 49.99 }
   ],
   customer: {
     email: 'customer@example.com',
@@ -102,311 +170,388 @@ const checkoutUrl = await torque.generateCartCheckoutUrl({
     }
   },
   options: {
-    metadata: {
-      orderId: 'order_123',
-      source: 'shopify'
-    },
-    expiresIn: 24 * 60 * 60 * 1000 // 24 hours
+    metadata: { orderId: 'order_123', source: 'website' },
+    expiresIn: 24 * 60 * 60 * 1000, // 24 hours
+    redirectUrl: 'https://yoursite.com/thank-you'
   }
 })
 ```
 
-#### `generateProductCheckoutUrl(productId: string, quantity?: number, customer?: CustomerData, options?: CartOptions): Promise<string>`
+##### `generateProductCheckoutUrl(productId, quantity, customer?, options?): Promise<string>`
 
 Generate a checkout URL for a single product.
 
-```typescript
-const checkoutUrl = await torque.generateProductCheckoutUrl(
+```ts
+const url = await torque.generateProductCheckoutUrl(
   'prod_123',
   2,
   { email: 'customer@example.com' }
 )
 ```
 
-#### `validateCart(cart: CartData): Promise<CartValidation>`
+##### `generateSubscriptionCheckoutUrl(productId, paymentPlanId, customer?, options?): Promise<string>`
 
-Validate cart data before generating checkout links.
+Generate a checkout URL for a subscription product.
 
-```typescript
-const validation = await torque.validateCart({
-  items: [
-    { productId: 'prod_123', quantity: 2 },
-    { productId: 'prod_456', quantity: 1 }
-  ]
-})
+```ts
+const url = await torque.generateSubscriptionCheckoutUrl(
+  'prod_subscription_123',
+  'plan_monthly_123',
+  { email: 'customer@example.com' }
+)
+```
+
+##### `validateCart(cart: CartData): Promise<CartValidation>`
+
+Validate cart data before generating checkout.
+
+```ts
+const validation = await torque.validateCart(cart)
 
 if (validation.valid) {
   console.log('Cart is valid, estimated total:', validation.estimatedTotal)
 } else {
-  console.log('Cart validation errors:', validation.errors)
+  console.error('Validation errors:', validation.errors)
 }
 ```
 
-#### `getOrderStatus(orderId: string): Promise<OrderStatus>`
+##### `getOrderStatus(orderId: string): Promise<OrderStatus>`
 
 Get the current status of an order.
 
-```typescript
-const orderStatus = await torque.getOrderStatus('order_123')
-console.log('Order status:', orderStatus.status)
-console.log('Total amount:', orderStatus.totals.total)
+```ts
+const order = await torque.getOrderStatus('order_123')
+console.log('Order status:', order.status)
+console.log('Total:', order.totals.total)
 ```
 
-#### `sendWebhookEvent(orderId: string, status: string, customerData?: any, metadata?: Record<string, any>): Promise<void>`
+### React Hooks
+
+#### `useTorqueCheckout(options?)`
+
+React hook for client-side checkout generation.
+
+```tsx
+import { useTorqueCheckout } from 'torque-checkout/react'
+
+function CheckoutButton() {
+  const {
+    generateCheckout,
+    generateProductCheckout,
+    generateSubscriptionCheckout,
+    validateCart,
+    getOrderStatus,
+    isLoading,
+    error,
+    checkoutUrl
+  } = useTorqueCheckout({
+    config: {
+      businessId: 'your_business_id',
+      apiKey: 'your_api_key'
+    },
+    // Or use environment variables (no config needed)
+    autoRedirect: true,
+    onSuccess: (url) => console.log('Success:', url),
+    onError: (error) => console.error('Error:', error)
+  })
 
-Send webhook events to update order status.
+  // Use the methods...
+}
+```
 
-```typescript
-await torque.sendWebhookEvent('order_123', 'shipped', {
-  trackingNumber: '1Z999AA1234567890',
-  carrier: 'UPS'
-})
+#### `useCart()`
+
+React hook for managing shopping cart state.
+
+```tsx
+import { useCart } from 'torque-checkout/react'
+
+function ShoppingCart() {
+  const {
+    items,
+    addItem,
+    removeItem,
+    updateQuantity,
+    clearCart,
+    getTotal,
+    getItemCount
+  } = useCart()
+
+  return (
+    <div>
+      <h2>Cart ({getItemCount()} items)</h2>
+      <p>Total: ${getTotal().toFixed(2)}</p>
+      {items.map(item => (
+        <div key={`${item.productId}-${item.variant}`}>
+          {item.productId} x {item.quantity}
+          <button onClick={() => removeItem(item.productId, item.variant)}>
+            Remove
+          </button>
+        </div>
+      ))}
+    </div>
+  )
+}
 ```
 
-#### `trackCartView(cartId: string, cartData: CartData): Promise<void>`
+### Next.js Server Utilities
 
-Track cart views for analytics.
+#### `generateCheckoutUrl(cart, config?)`
 
-```typescript
-await torque.trackCartView('cart_123', {
-  items: [{ productId: 'prod_123', quantity: 2 }]
-})
+Generate checkout URL on the server.
+
+```ts
+// app/api/checkout/route.ts
+import { generateCheckoutUrl } from 'torque-checkout/nextjs'
+
+export async function POST(request: Request) {
+  const cart = await request.json()
+  const url = await generateCheckoutUrl(cart)
+  return Response.json({ checkoutUrl: url })
+}
 ```
 
-#### `trackCheckoutComplete(orderId: string, checkoutData: any): Promise<void>`
+#### `handleCheckoutRequest(options?)`
+
+Next.js API route handler for checkout generation.
 
-Track successful checkout completions.
+```ts
+// app/api/checkout/route.ts
+import { handleCheckoutRequest } from 'torque-checkout/nextjs'
 
-```typescript
-await torque.trackCheckoutComplete('order_123', {
-  paymentMethod: 'card',
-  total: 99.99
+export const POST = handleCheckoutRequest({
+  onSuccess: async (url, cart) => {
+    // Log or process checkout
+    console.log('Checkout generated:', url)
+  },
+  onError: async (error, cart) => {
+    // Handle error
+    console.error('Checkout error:', error)
+  }
 })
 ```
 
-#### `generateCartHash(cart: CartData): string`
+#### `handleWebhook(options?)`
+
+Next.js API route handler for webhook events.
 
-Generate a unique hash for cart identification and caching.
+```ts
+// app/api/webhooks/torque/route.ts
+import { handleWebhook } from 'torque-checkout/nextjs'
 
-```typescript
-const cartHash = torque.generateCartHash({
-  items: [{ productId: 'prod_123', quantity: 2 }]
+export const POST = handleWebhook({
+  secret: process.env.TORQUE_WEBHOOK_SECRET,
+  onOrderCompleted: async (event) => {
+    // Fulfill order
+    await fulfillOrder(event.orderId!)
+  },
+  onOrderFailed: async (event) => {
+    // Handle failed order
+    await notifyCustomer(event.orderId!)
+  }
 })
 ```
 
-## Data Types
+## 🎯 Complete Examples
 
-### CartItem
+### Next.js App Router - Full E-Commerce Integration
 
-```typescript
-interface CartItem {
-  productId: string        // Required: Torque product ID
-  quantity: number         // Required: Quantity to purchase
-  variant?: string         // Optional: Product variant (size, color, etc.)
-  price?: number           // Optional: Override product price
-  metadata?: Record<string, any> // Optional: Custom data
-}
-```
+```tsx
+// app/products/[id]/page.tsx
+'use client'
 
-### CustomerData
-
-```typescript
-interface CustomerData {
-  email: string            // Required: Customer email
-  firstName?: string       // Optional: First name
-  lastName?: string        // Optional: Last name
-  phone?: string           // Optional: Phone number
-  shippingAddress?: {      // Optional: Pre-fill shipping address
-    street: string
-    city: string
-    state: string
-    zipCode: string
-    country: string
-  }
-  billingAddress?: {       // Optional: Pre-fill billing address
-    // Same structure as shippingAddress
+import { useTorqueCheckout, useCart } from 'torque-checkout/react'
+import { useState } from 'react'
+
+export default function ProductPage({ params }: { params: { id: string } }) {
+  const { addItem, items, getItemCount } = useCart()
+  const { generateProductCheckout, isLoading } = useTorqueCheckout({
+    autoRedirect: true
+  })
+  const [quantity, setQuantity] = useState(1)
+
+  const handleAddToCart = () => {
+    addItem({
+      productId: params.id,
+      quantity,
+      price: 29.99 // Your product price
+    })
   }
-}
-```
 
-### CartOptions
+  const handleCheckout = async () => {
+    await generateProductCheckout(
+      params.id,
+      quantity,
+      {
+        email: 'customer@example.com' // Get from user session
+      }
+    )
+  }
 
-```typescript
-interface CartOptions {
-  domain?: string          // Optional: Custom domain for checkout
-  expiresIn?: number       // Optional: Link expiration time (ms)
-  metadata?: Record<string, any> // Optional: Custom metadata
-  redirectUrl?: string     // Optional: Post-checkout redirect URL
+  return (
+    <div>
+      <h1>Product {params.id}</h1>
+      <div>
+        <label>Quantity:</label>
+        <input
+          type="number"
+          value={quantity}
+          onChange={(e) => setQuantity(Number(e.target.value))}
+          min="1"
+        />
+      </div>
+      <button onClick={handleAddToCart}>Add to Cart</button>
+      <button onClick={handleCheckout} disabled={isLoading}>
+        {isLoading ? 'Processing...' : 'Checkout'}
+      </button>
+      <p>Cart: {getItemCount()} items</p>
+    </div>
+  )
 }
 ```
 
-## Platform Integrations
+### Next.js Pages Router - API Route
 
-### Shopify
+```ts
+// pages/api/checkout.ts
+import type { NextApiRequest, NextApiResponse } from 'next'
+import { createTorqueCheckoutFromEnv } from 'torque-checkout'
+
+export default async function handler(
+  req: NextApiRequest,
+  res: NextApiResponse
+) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' })
+  }
 
-```typescript
-// Shopify app integration
-app.post('/checkout', async (req, res) => {
-  const { cart, customer } = req.body
-  
   try {
-    const checkoutUrl = await torque.generateCartCheckoutUrl({
-      items: cart.items.map(item => ({
-        productId: item.product_id,
-        quantity: item.quantity,
-        variant: item.variant_title,
-        price: item.price
-      })),
-      customer: {
-        email: customer.email,
-        firstName: customer.first_name,
-        lastName: customer.last_name,
-        shippingAddress: customer.shipping_address
-      },
-      options: {
-        metadata: {
-          orderId: cart.order_id,
-          source: 'shopify'
-        }
-      }
+    const torque = createTorqueCheckoutFromEnv()
+    const checkoutUrl = await torque.generateCartCheckoutUrl(req.body)
+
+    res.status(200).json({ checkoutUrl })
+  } catch (error: any) {
+    res.status(500).json({
+      error: error.message,
+      code: error.code
     })
-    
-    res.json({ checkoutUrl })
-  } catch (error) {
-    res.status(500).json({ error: error.message })
   }
-})
+}
 ```
 
-### WooCommerce
+### Server Component (Next.js 13+)
 
-```php
-// WooCommerce hook integration
-add_action('woocommerce_checkout_order_processed', 'redirect_to_torque_checkout', 10, 3);
+```tsx
+// app/checkout/page.tsx
+import { createTorqueCheckoutFromEnv } from 'torque-checkout'
+import { redirect } from 'next/navigation'
 
-function redirect_to_torque_checkout($order_id, $posted_data, $order) {
-    $cart_items = [];
-    
-    foreach ($order->get_items() as $item) {
-        $cart_items[] = [
-            'productId' => $item->get_product_id(),
-            'quantity' => $item->get_quantity(),
-            'variant' => $item->get_variation_id() ? $item->get_name() : null,
-            'price' => $item->get_total() / $item->get_quantity()
-        ];
-    }
-    
-    $checkout_data = [
-        'businessId' => get_option('torque_business_id'),
-        'cart' => ['items' => $cart_items],
-        'customerData' => [
-            'email' => $order->get_billing_email(),
-            'firstName' => $order->get_billing_first_name(),
-            'lastName' => $order->get_billing_last_name()
-        ]
-    ];
-    
-    // Use JavaScript SDK or direct API call
-    $response = wp_remote_post('https://dashboard.torque.fi/api/checkout/generate-link', [
-        'body' => json_encode($checkout_data),
-        'headers' => ['Content-Type' => 'application/json'],
-        'timeout' => 30
-    ]);
-    
-    if (!is_wp_error($response)) {
-        $body = json_decode(wp_remote_retrieve_body($response), true);
-        if ($body['checkoutUrl']) {
-            wp_redirect($body['checkoutUrl']);
-            exit;
-        }
+export default async function CheckoutPage({
+  searchParams
+}: {
+  searchParams: { productId: string; quantity?: string }
+}) {
+  const torque = createTorqueCheckoutFromEnv()
+  
+  const checkoutUrl = await torque.generateProductCheckoutUrl(
+    searchParams.productId,
+    Number(searchParams.quantity) || 1,
+    {
+      email: 'customer@example.com' // Get from session
     }
+  )
+
+  redirect(checkoutUrl)
 }
 ```
 
-## Testing
-
-### Test Environment
-
-Use our sandbox environment for testing:
-
-```typescript
-const torque = new TorqueCheckout({
-  businessId: 'test_business_123',
-  apiKey: 'test_api_key'
-})
+## 🔧 TypeScript Types
+
+The SDK provides comprehensive TypeScript types:
+
+```ts
+import type {
+  CartItem,
+  CartData,
+  CustomerData,
+  CartOptions,
+  CheckoutResponse,
+  OrderStatus,
+  CartValidation,
+  Subscription,
+  SubscriptionProduct,
+  PaymentPlan,
+  TorqueConfig,
+  TorqueCheckoutError
+} from 'torque-checkout'
 ```
 
-### Test Data
+## 🛡️ Error Handling
 
-```typescript
-const testCart = {
-  items: [
-    { productId: 'test_prod_1', quantity: 1, price: 10.00 }
-  ],
-  customer: {
-    email: 'test@example.com'
-  }
-}
+The SDK uses custom error classes for better error handling:
 
-const checkoutUrl = await torque.generateCartCheckoutUrl(testCart)
-```
+```ts
+import { TorqueCheckoutError } from 'torque-checkout'
 
-## Error Handling
-
-The SDK throws descriptive errors for various failure scenarios:
-
-```typescript
 try {
-  const checkoutUrl = await torque.generateCartCheckoutUrl(cart)
+  const url = await torque.generateCartCheckoutUrl(cart)
 } catch (error) {
-  if (error.message.includes('BUSINESS_NOT_FOUND')) {
-    console.error('Invalid business ID')
-  } else if (error.message.includes('PRODUCTS_NOT_FOUND')) {
-    console.error('Some products not found')
-  } else if (error.message.includes('Request timeout')) {
-    console.error('API request timed out')
-  } else {
-    console.error('Unexpected error:', error.message)
+  if (error instanceof TorqueCheckoutError) {
+    console.error('Error code:', error.code)
+    console.error('Status code:', error.statusCode)
+    console.error('Details:', error.details)
+    
+    // Handle specific error codes
+    switch (error.code) {
+      case 'VALIDATION_ERROR':
+        // Handle validation errors
+        break
+      case 'BUSINESS_NOT_FOUND':
+        // Handle business not found
+        break
+      case 'TIMEOUT':
+        // Handle timeout
+        break
+      default:
+        // Handle other errors
+    }
   }
 }
 ```
 
-## Analytics & Tracking
+## 🔐 Security Best Practices
 
-Track customer behavior and optimize conversions:
+1. **Never expose API keys in client-side code** - Use environment variables and server-side API routes
+2. **Validate all input** - The SDK includes validation, but always validate user input
+3. **Use HTTPS** - Always use HTTPS in production
+4. **Verify webhook signatures** - Use the webhook secret to verify webhook authenticity
+5. **Set payment wallet in business settings** - Payments automatically go to your configured wallet
 
-```typescript
-// Track cart abandonment
-await torque.trackCartView('cart_123', cartData)
+## 📖 API Reference
 
-// Track successful checkouts
-await torque.trackCheckoutComplete('order_123', {
-  paymentMethod: 'card',
-  total: 99.99,
-  items: 3
-})
-```
+See the [full API documentation](https://docs.torque.fi/api) for complete reference.
 
-## Payment Destination
+## 🤝 Support
 
-**Payments are transferred to the wallet address set in business profile.**
+- **Documentation**: [https://docs.torque.fi](https://docs.torque.fi)
+- **Email**: hello@torque.fi
+- **GitHub Issues**: [https://github.com/torque-fi/torque-checkout/issues](https://github.com/torque-fi/torque-checkout/issues)
 
-- **Set once**: Configure your payment wallet in business settings
-- **Automatic transfers**: All successful checkouts send funds to your wallet
-- **Secure**: No need to handle payment addresses in your code
-- **Update anytime**: Change your payment wallet in business settings
+## 📄 License
 
-## Performance
+MIT © [Torque](https://torque.fi)
 
-- Built-in request caching with cart hashing
-- Configurable timeouts
-- Efficient error handling
-- Minimal bundle size
+## 🎉 Getting Started Checklist
 
-## Support
+- [ ] Install the package: `npm install torque-checkout`
+- [ ] Create Torque business profile at [app.torque.fi/business/settings](https://app.torque.fi/business/settings)
+- [ ] Set payment wallet address in business settings
+- [ ] Copy Business ID and API Key
+- [ ] Add environment variables to `.env.local`
+- [ ] Import and use the SDK in your code
+- [ ] Test checkout flow
+- [ ] Deploy to production! 🚀
 
-- **Documentation**: [https://docs.torque.fi](https://docs.torque.fi)
-- **API Reference**: [https://docs.torque.fi/api](https://docs.torque.fi/api)
-- **Integration Guide**: [https://docs.torque.fi/integrations](https://docs.torque.fi/integrations)
-- **NPM Package**: [https://www.npmjs.com/package/torque-checkout](https://www.npmjs.com/package/torque-checkout)
-- **Support**: hello@torque.fi
+---
+
+**Made with ❤️ by [Torque](https://torque.fi)**