@bloque/payments 0.0.9 → 0.0.11

package/README.md

@@ -1,14 +1,6 @@
 # Bloque Payments SDK
 
-The official TypeScript/JavaScript SDK for integrating [Bloque](https://www.bloque.app) payments into your applications.
-
-## Features
-
-- **TypeScript First**: Built with TypeScript for complete type safety
-- **Simple API**: Intuitive interface for creating and managing checkouts
-- **Multiple Payment Methods**: Support for cards, PSE, and cash payments
-- **Fully Async**: Promise-based API for modern JavaScript workflows
-- **Lightweight**: Minimal dependencies for optimal bundle size
+Official TypeScript/JavaScript SDK for integrating Bloque payments.
 
 ## Installation
 
@@ -16,630 +8,188 @@ The official TypeScript/JavaScript SDK for integrating [Bloque](https://www.bloq
 bun add @bloque/payments
 ```
 
-## Quick Start
-
-```typescript
-import { Bloque, type PaymentSubmitPayload } from '@bloque/payments';
-
-// Initialize the SDK (server-side only)
-const bloque = new Bloque({
-  apiKey: process.env.BLOQUE_API_KEY!,
-  mode: 'production', // or 'sandbox' for testing
-});
-
-app.post('/api/payments', async (req, res) => {
-  try {
-    const payload: PaymentSubmitPayload = req.body;
-
-    // Create payment using SDK
-    const payment = await bloque.payments.create({
-      payment: payload,
-    });
-
-    res.json({ success: true, payment });
-  } catch (error) {
-    res.status(500).json({ success: false, error: error.message });
-  }
-});
-```
+## Initialize
 
-## Configuration
-
-### Initialize the SDK
-
-```typescript
+```ts
 import { Bloque } from '@bloque/payments';
 
 const bloque = new Bloque({
-  apiKey: 'your-api-key-here',    // Required: Your Bloque API key
-  mode: 'sandbox',               // Required: 'sandbox' or 'production'
-});
-```
-
-### Environment Options
-
-- **`sandbox`**: For testing and development
-- **`production`**: For live payments
-
-## API Reference
-
-### Payments
-
-The payments resource allows you to create payments for existing checkout sessions.
-
-#### Create a Payment
-
-```typescript
-const payment = await bloque.payments.create({
-  checkoutId: string;        // Required: Checkout ID from an existing checkout
-  payment: {
-    type: 'card' | 'pse' | 'cash',
-    data: {
-      // Payment method specific data
-    }
-  }
-});
-```
-
-**Payment Types**:
-
-**Card Payment**:
-```typescript
-{
-  type: 'card',
-  data: {
-    cardNumber: string;        // 16-digit card number
-    cardholderName: string;    // Name on the card
-    expiryMonth: string;       // MM format
-    expiryYear: string;        // YY or YYYY format
-    cvv: string;               // 3-4 digit CVV
-    email?: string;            // Optional customer email
-  }
-}
-```
-
-**PSE Payment** (Colombian online banking):
-```typescript
-{
-  type: 'pse',
-  data: {
-    personType: 'natural' | 'juridica';  // Person type
-    documentType: string;                 // Document type (e.g., 'CC', 'NIT')
-    documentNumber: string;               // Document number
-    bankCode: string;                     // Bank code
-    email: string;                        // Customer email
-  }
-}
-```
-
-**Cash Payment**:
-```typescript
-{
-  type: 'cash',
-  data: {
-    email: string;            // Customer email
-    documentType: string;     // Document type
-    documentNumber: string;   // Document number
-    fullName: string;         // Full name
-  }
-}
-```
-
-**Payment Response**:
-```typescript
-{
-  id: string;                       // Payment ID
-  object: 'payment';                // Object type
-  status: 'pending' | 'processing' | 'completed' | 'failed';
-  checkout: Checkout;               // Associated checkout
-  payment_method: 'card' | 'pse' | 'cash';
-  amount: number;                   // Payment amount
-  currency: string;                 // Currency
-  created_at: string;               // Creation timestamp
-  updated_at: string;               // Last update timestamp
-}
-```
-
-### Checkout
-
-The checkout resource allows you to create payment sessions.
-
-#### Create a Checkout
-
-```typescript
-const checkout = await bloque.checkout.create({
-  name: string;              // Required: Name of the checkout
-  description?: string;      // Optional: Description
-  image_url?: string;        // Optional: Product/checkout image URL
-  items: CheckoutItem[];     // Required: Items to be purchased
-  success_url: string;       // Required: Redirect URL after success
-  cancel_url: string;        // Required: Redirect URL after cancellation
-  metadata?: Record<string, string | number | boolean>; // Optional: Custom metadata
-  expires_at?: string;       // Optional: Expiration date (ISO 8601)
-});
-```
-
-**Checkout Item**:
-```typescript
-{
-  name: string;        // Item name
-  amount: number;      // Price in smallest currency unit (e.g., cents)
-  quantity: number;    // Quantity
-  image_url?: string;  // Item image URL
-}
-```
-
-#### Checkout Response
-
-```typescript
-{
-  id: string;                // Unique checkout identifier
-  object: 'checkout';        // Object type
-  url: string;               // Public payment URL for the customer
-  status: string;            // Current checkout status
-  amount_total: number;      // Total amount
-  amount_subtotal: number;   // Subtotal amount
-  currency: 'USD';           // Currency
-  items: CheckoutItem[];     // Items in the checkout
-  metadata?: Metadata;       // Custom metadata
-  created_at: string;        // Creation timestamp (ISO 8601)
-  updated_at: string;        // Last update timestamp (ISO 8601)
-  expires_at: string;        // Expiration timestamp (ISO 8601)
-}
-```
-
-#### Retrieve a Checkout
-
-Retrieve the details of an existing checkout by its ID.
-
-```typescript
-const checkout = await bloque.checkout.retrieve('checkout_id_here');
-```
-
-**Parameters**:
-- `checkoutId` (string): The ID of the checkout to retrieve
-
-**Returns**: A `Checkout` object with all the checkout details.
-
-#### Cancel a Checkout
-
-Cancel an existing checkout that hasn't been completed yet.
-
-```typescript
-const checkout = await bloque.checkout.cancel('checkout_id_here');
-```
-
-**Parameters**:
-- `checkoutId` (string): The ID of the checkout to cancel
-
-**Returns**: A `Checkout` object with updated status reflecting the cancellation.
-
-### Webhooks
-
-The webhooks resource allows you to verify the authenticity of webhook events sent from Bloque.
-
-#### Verify Webhook Signature
-
-Verify that a webhook event was actually sent by Bloque using HMAC-SHA256 signature verification.
-
-```typescript
-const isValid = bloque.webhooks.verify(
-  requestBody,
-  signatureHeader,
-  { secret: process.env.WEBHOOK_SECRET }
-);
-
-if (isValid) {
-  // Process the webhook event
-} else {
-  // Reject the webhook
-}
-```
-
-**Parameters**:
-- `body` (string | object): The raw webhook request body
-- `signature` (string): The signature from the `x-bloque-signature` header
-- `options` (optional): Verification options
-  - `secret` (string): Webhook secret key. Can be set during SDK initialization or passed here
-
-**Returns**: `boolean` - `true` if the webhook signature is valid, `false` otherwise
-
-**Configuration**:
-
-You can set the webhook secret during SDK initialization:
-
-```typescript
-const bloque = new Bloque({
-  apiKey: process.env.BLOQUE_API_KEY!,
-  mode: 'production',
-  webhookSecret: process.env.BLOQUE_WEBHOOK_SECRET,
-});
-
-// Then you can verify without passing the secret each time
-const isValid = bloque.webhooks.verify(body, signature);
-```
-
-Or pass it directly during verification:
-
-```typescript
-const isValid = bloque.webhooks.verify(body, signature, {
-  secret: process.env.BLOQUE_WEBHOOK_SECRET,
+  mode: 'sandbox', // 'sandbox' | 'production'
+  accessToken: process.env.BLOQUE_ACCESS_TOKEN!,
+  webhookSecret: process.env.BLOQUE_WEBHOOK_SECRET, // optional
 });
 ```
 
-## Examples
+## Quick Start: Create Checkout
 
-### Processing Payments
-
-```typescript
-import { Bloque, type PaymentSubmitPayload } from '@bloque/payments';
-
-// Initialize SDK with your API key
-const bloque = new Bloque({
-  apiKey: process.env.BLOQUE_API_KEY!,
-  mode: 'production',
-});
-
-// API endpoint handler
-app.post('/api/payments', async (req, res) => {
-  try {
-    // Receive payment data from frontend
-    const payload: PaymentSubmitPayload = req.body;
-
-    // Create payment using SDK
-    const payment = await bloque.payments.create({
-      payment: payload,
-    });
-
-    res.json({ success: true, payment });
-  } catch (error) {
-    res.status(500).json({ success: false, error: error.message });
-  }
-});
-```
-
-### Payment Methods Examples
-
-#### Card Payment
-
-```typescript
-// Receive payload from frontend
-const cardPayment: PaymentSubmitPayload = req.body;
-// Example payload:
-// {
-//   type: 'card',
-//   data: {
-//     cardNumber: '4111111111111111',
-//     cardholderName: 'John Doe',
-//     expiryMonth: '12',
-//     expiryYear: '2025',
-//     cvv: '123',
-//     email: 'john@example.com'
-//   }
-// }
-
-const payment = await bloque.payments.create({
-  payment: cardPayment,
-});
-```
-
-#### PSE Payment (Colombian online banking)
-
-```typescript
-// Receive payload from frontend
-const psePayment: PaymentSubmitPayload = req.body;
-// Example payload:
-// {
-//   type: 'pse',
-//   data: {
-//     personType: 'natural',
-//     documentType: 'CC',
-//     documentNumber: '1234567890',
-//     bankCode: '1022',
-//     email: 'maria@example.com'
-//   }
-// }
-
-const payment = await bloque.payments.create({
-  payment: psePayment,
-});
-```
-
-#### Cash Payment
-
-```typescript
-// Receive payload from frontend
-const cashPayment: PaymentSubmitPayload = req.body;
-// Example payload:
-// {
-//   type: 'cash',
-//   data: {
-//     email: 'carlos@example.com',
-//     documentType: 'CC',
-//     documentNumber: '9876543210',
-//     fullName: 'Carlos García'
-//   }
-// }
-
-const payment = await bloque.payments.create({
-  payment: cashPayment,
-});
-```
-
-### Type-Safe Payment Creation
-
-The `PaymentSubmitPayload` type is a discriminated union that provides automatic type narrowing:
-
-```typescript
-// Backend API handler
-async function handlePayment(payload: PaymentSubmitPayload) {
-  // TypeScript automatically narrows the type based on the 'type' field
-  switch (payload.type) {
-    case 'card':
-      // payload.data is CardPaymentFormData
-      console.log('Processing card ending in:', payload.data.cardNumber.slice(-4));
-      break;
-
-    case 'pse':
-      // payload.data is PSEPaymentFormData
-      console.log('Processing PSE for bank:', payload.data.bankCode);
-      break;
-
-    case 'cash':
-      // payload.data is CashPaymentFormData
-      console.log('Processing cash payment for:', payload.data.fullName);
-      break;
-  }
-
-  // Create payment using SDK
-  return await bloque.payments.create({
-    payment: payload,
-  });
-}
-```
-
-### Webhook Handler
-
-Handle incoming webhook events from Bloque and verify their authenticity:
-
-```typescript
+```ts
 import { Bloque } from '@bloque/payments';
 
-// Initialize SDK with webhook secret
 const bloque = new Bloque({
-  apiKey: process.env.BLOQUE_API_KEY!,
-  mode: 'production',
-  webhookSecret: process.env.BLOQUE_WEBHOOK_SECRET,
+  mode: 'sandbox',
+  accessToken: process.env.BLOQUE_ACCESS_TOKEN!,
 });
 
-// Webhook endpoint
-app.post(
-  '/webhooks/bloque',
-  (req, res) => {
-    const signature = req.headers['x-bloque-signature'] as string;
-
-    try {
-      // Verify the webhook signature
-      const isValid = bloque.webhooks.verify(req.body.toString(), signature);
-
-      if (!isValid) {
-        return res.status(400).send('Invalid signature');
-      }
-
-      // Parse and process the event
-      const event = JSON.parse(req.body.toString());
-
-      switch (event.type) {
-        case 'checkout.completed':
-          console.log('Checkout completed:', event.data);
-          // Update database, send confirmation, etc.
-          break;
-
-        case 'payment.succeeded':
-          console.log('Payment succeeded:', event.data);
-          break;
-
-        case 'payment.failed':
-          console.log('Payment failed:', event.data);
-          break;
-      }
-
-      res.json({ received: true });
-    } catch (error) {
-      console.error('Webhook error:', error);
-      res.status(400).send('Webhook error');
-    }
-  },
-);
-```
-
-### Basic Checkout with Single Item
-
-```typescript
 const checkout = await bloque.checkout.create({
-  name: 'E-book Purchase',
-  description: 'Learn TypeScript in 30 Days',
+  name: 'Pack Profesional de Productividad',
+  description:
+    'Periféricos premium para trabajo intensivo y alto rendimiento',
+  asset: 'COPM/2',
+  image_url: 'https://cdn.bloque.app/checkouts/productivity-pack.png',
   items: [
     {
-      name: 'TypeScript E-book',
-      amount: 19_99,
-      quantity: 1,
-    },
-  ],
-  success_url: 'https://yourapp.com/success',
-  cancel_url: 'https://yourapp.com/cancel',
-});
-```
-
-### Checkout with Multiple Items
-
-```typescript
-const checkout = await bloque.checkout.create({
-  name: 'Shopping Cart',
-  description: 'Your selected items',
-  items: [
-    {
-      name: 'Wireless Mouse',
-      amount: 25_00,
-      quantity: 1,
-      image_url: 'https://example.com/mouse.jpg',
-    },
-    {
-      name: 'USB Cable',
-      amount: 10_00,
+      name: 'Teclado mecánico Keychron K2',
+      description: 'Wireless, RGB, switches Blue',
+      amount: 450_000_00,
       quantity: 2,
-      image_url: 'https://example.com/cable.jpg',
+      image_url: 'https://cdn.bloque.app/items/keychron-k2.png',
     },
-  ],
-  success_url: 'https://yourapp.com/success',
-  cancel_url: 'https://yourapp.com/cancel',
-});
-```
-
-### Checkout with Metadata and Expiration
-
-```typescript
-const checkout = await bloque.checkout.create({
-  name: 'Limited Time Offer',
-  items: [
     {
-      name: 'Premium Course',
-      amount: 99_00,
+      name: 'Mouse Logitech MX Master 3S',
+      description: 'Inalámbrico, sensor 8K DPI',
+      amount: 380_000_00,
       quantity: 1,
+      image_url: 'https://cdn.bloque.app/items/mx-master-3s.png',
     },
   ],
-  success_url: 'https://yourapp.com/success',
-  cancel_url: 'https://yourapp.com/cancel',
-  metadata: {
-    user_id: '12345',
-    campaign: 'summer_sale',
-    discount_applied: true,
-  },
-  expires_at: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(), // 24 hours
+  success_url: 'https://bloque.app/success',
+  cancel_url: 'https://bloque.app/cancel',
 });
-```
 
+console.log('Checkout URL:', checkout.url);
+```
 
-## Error Handling
+## API
 
-The SDK uses standard JavaScript errors. Always wrap API calls in try-catch blocks:
+### `Bloque` config
 
-```typescript
-try {
-  const checkout = await bloque.checkout.create({
-    name: 'Product',
-    items: [{ name: 'Item', amount: 1000, quantity: 1 }],
-    success_url: 'https://yourapp.com/success',
-    cancel_url: 'https://yourapp.com/cancel',
-  });
-} catch (error) {
-  console.error('Failed to create checkout:', error);
-}
+```ts
+type BloqueConfig = {
+  mode: 'sandbox' | 'production';
+  accessToken: string;
+  timeout?: number;
+  maxRetries?: number;
+  webhookSecret?: string;
+};
 ```
 
-## TypeScript Support
-
-This SDK is written in TypeScript and includes complete type definitions. You'll get full autocomplete and type checking when using TypeScript or modern editors like VS Code:
-
-```typescript
-import type {
-  // Payment types
-  PaymentSubmitPayload,
-  PaymentResponse,
-  CreatePaymentParams,
-  // Checkout types
-  Checkout,
-  CheckoutStatus,
-  CheckoutItem,
-  CheckoutParams,
-  // Webhook types
-  WebhookVerifyOptions,
-} from '@bloque/payments';
-
-const item: CheckoutItem = {
-  name: 'Product',
-  amount: 5000,
-  quantity: 1,
-};
+### Checkout
 
-// Type-safe payment data
-const cardPayment: PaymentSubmitPayload = {
-  type: 'card',
-  data: {
-    cardNumber: '4111111111111111',
-    cardholderName: 'John Doe',
-    expiryMonth: '12',
-    expiryYear: '2025',
-    cvv: '123',
-  },
+#### `bloque.checkout.create(params)`
+
+```ts
+type CheckoutParams = {
+  name: string;
+  description?: string;
+  image_url?: string;
+  asset?: 'COPM/2' | 'DUSD/6';
+  items: {
+    name: string;
+    description?: string;
+    amount: number;
+    quantity: number;
+    image_url?: string;
+  }[];
+  success_url: string;
+  cancel_url: string;
+  metadata?: Record<string, string | number | boolean>;
+  expires_at?: string;
 };
 ```
 
-**Discriminated Union Types**:
-
-The SDK uses TypeScript discriminated unions for payment types, which enables automatic type narrowing:
-
-```typescript
-// Backend API handler
-async function handlePaymentFromFrontend(payment: PaymentSubmitPayload) {
-  switch (payment.type) {
-    case 'card':
-      // TypeScript knows payment.data is CardPaymentFormData
-      console.log('Card payment for:', payment.data.cardholderName);
-      break;
-    case 'pse':
-      // TypeScript knows payment.data is PSEPaymentFormData
-      console.log('PSE payment, bank:', payment.data.bankCode);
-      break;
-    case 'cash':
-      // TypeScript knows payment.data is CashPaymentFormData
-      console.log('Cash payment for:', payment.data.fullName);
-      break;
-  }
-
-  return await bloque.payments.create({ payment });
-}
+Notes:
+- `asset` defaults to `DUSD/6` when omitted.
+- Creation request is sent using `redirect_url` derived from `success_url`.
+
+Response shape:
+
+```ts
+type Checkout = {
+  id: string;
+  object: 'checkout';
+  url: string;
+  status: 'pending' | 'completed' | 'expired' | 'canceled';
+  amount_total: number;
+  amount_subtotal: number;
+  asset: 'COPM/2' | 'DUSD/6';
+  items: {
+    name: string;
+    description?: string;
+    amount: number;
+    quantity: number;
+    image_url?: string;
+  }[];
+  metadata?: Record<string, string | number | boolean>;
+  created_at: string;
+  updated_at: string;
+  expires_at: string | null;
+};
 ```
 
-## Development
-
-### Building the SDK
+#### `bloque.checkout.retrieve(checkoutId)`
 
-```bash
-bun install
-bun run build
+```ts
+const checkout = await bloque.checkout.retrieve('checkout_123');
 ```
 
-### Development Mode (Watch)
+#### `bloque.checkout.cancel(checkoutId)`
 
-```bash
-bun run dev
+```ts
+const checkout = await bloque.checkout.cancel('checkout_123');
 ```
 
-### Type Checking
+### Payments
 
-```bash
-bun run typecheck
-```
+#### `bloque.payments.create(params)`
 
-### Code Quality
+Current supported submit payload is card:
 
-```bash
-bun run check
+```ts
+const payment = await bloque.payments.create({
+  checkoutId: 'checkout_123',
+  payment: {
+    type: 'card',
+    data: {
+      cardNumber: '4111111111111111',
+      cardholderName: 'John Doe',
+      expiryMonth: '12',
+      expiryYear: '2028',
+      cvv: '123',
+      email: 'john@example.com',
+    },
+  },
+});
 ```
 
-## Requirements
+Payment response:
+
+```ts
+type PaymentResponse = {
+  id: string;
+  object: 'payment';
+  status: 'pending' | 'processing' | 'completed' | 'failed';
+  amount: number;
+  currency: string;
+  created_at: string;
+  updated_at: string;
+};
+```
 
-- Node.js 22.x or higher / Bun 1.x or higher
-- TypeScript 5.x or higher (for TypeScript projects)
+### Webhooks
 
-## Links
+Verify webhook signature (`HMAC-SHA256`):
 
-- [Homepage](https://www.bloque.app)
-- [GitHub Repository](git+https://github.com/bloque-app/payments.git)
-- [Issue Tracker](git+https://github.com/bloque-app/payments.git/issues)
+```ts
+const isValid = bloque.webhooks.verify(
+  rawBody,
+  signature,
+  { secret: process.env.BLOQUE_WEBHOOK_SECRET! },
+);
+```
 
-## License
+You can also set `webhookSecret` during `Bloque` initialization and omit `options` in `verify`.
 
-[MIT](../../LICENSE)
+## Example
 
+Full example available at:
+- `examples/basic-checkout.ts`

package/dist/index.cjs

@@ -26,7 +26,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     Bloque: ()=>Bloque
 });
-var package_namespaceObject = JSON.parse('{"UU":"@bloque/payments","rE":"0.0.9"}');
+var package_namespaceObject = JSON.parse('{"UU":"@bloque/payments","rE":"0.0.11"}');
 class BloqueError extends Error {
     constructor(message){
         super(message);
@@ -102,11 +102,12 @@ class HttpClient {
         throw lastError ?? new BloqueError('Request failed after retries');
     }
     buildURL(path, params) {
-        const url = new URL(path, this.baseURL);
+        const url = `${this.baseURL}${path.startsWith('/') ? path : `/${path}`}`;
+        const urlObj = new URL(url);
         if (params) {
-            for (const [key, value] of Object.entries(params))if (null != value) url.searchParams.append(key, String(value));
+            for (const [key, value] of Object.entries(params))if (null != value) urlObj.searchParams.append(key, String(value));
         }
-        return url.toString();
+        return urlObj.toString();
     }
     buildHeaders(customHeaders, idempotencyKey) {
         return {
@@ -200,14 +201,14 @@ class CheckoutResource extends BaseResource {
     async create(params) {
         const items = params.items.map((item)=>({
                 name: item.name,
-                price: item.amount.toString(),
-                units: item.quantity,
+                amount: item.amount.toString(),
+                quantity: item.quantity,
                 image_url: item.image_url
             }));
         const payload = {
             name: params.name,
             description: params.description,
-            asset: 'dUSD/6',
+            asset: params.asset ?? 'DUSD/6',
             payment_type: 'shopping_cart',
             image_url: params.image_url,
             items: items,
@@ -215,20 +216,20 @@ class CheckoutResource extends BaseResource {
             expires_at: params.expires_at,
             metadata: params.metadata
         };
-        const response = await this.http.post('/checkout', payload);
+        const response = await this.http.post('/', payload);
         return {
             id: response.payment.urn,
             object: 'checkout',
             url: response.payment.url,
             status: response.payment.summary.status,
-            amount_total: response.payment.price,
-            amount_subtotal: response.payment.price,
-            currency: 'USD',
+            amount_total: response.payment.amount,
+            amount_subtotal: response.payment.amount,
+            asset: response.payment.asset,
             items: params.items,
             created_at: response.payment.created_at,
             updated_at: response.payment.updated_at,
             expires_at: response.payment.expires_at,
-            metadata: response.payment.metadata
+            metadata: response.payment.metadata ?? void 0
         };
     }
     async retrieve(checkoutId) {

package/dist/index.js

@@ -1,5 +1,5 @@
 import { createHmac } from "node:crypto";
-var package_namespaceObject = JSON.parse('{"UU":"@bloque/payments","rE":"0.0.9"}');
+var package_namespaceObject = JSON.parse('{"UU":"@bloque/payments","rE":"0.0.11"}');
 class BloqueError extends Error {
     constructor(message){
         super(message);
@@ -75,11 +75,12 @@ class HttpClient {
         throw lastError ?? new BloqueError('Request failed after retries');
     }
     buildURL(path, params) {
-        const url = new URL(path, this.baseURL);
+        const url = `${this.baseURL}${path.startsWith('/') ? path : `/${path}`}`;
+        const urlObj = new URL(url);
         if (params) {
-            for (const [key, value] of Object.entries(params))if (null != value) url.searchParams.append(key, String(value));
+            for (const [key, value] of Object.entries(params))if (null != value) urlObj.searchParams.append(key, String(value));
         }
-        return url.toString();
+        return urlObj.toString();
     }
     buildHeaders(customHeaders, idempotencyKey) {
         return {
@@ -173,14 +174,14 @@ class CheckoutResource extends BaseResource {
     async create(params) {
         const items = params.items.map((item)=>({
                 name: item.name,
-                price: item.amount.toString(),
-                units: item.quantity,
+                amount: item.amount.toString(),
+                quantity: item.quantity,
                 image_url: item.image_url
             }));
         const payload = {
             name: params.name,
             description: params.description,
-            asset: 'dUSD/6',
+            asset: params.asset ?? 'DUSD/6',
             payment_type: 'shopping_cart',
             image_url: params.image_url,
             items: items,
@@ -188,20 +189,20 @@ class CheckoutResource extends BaseResource {
             expires_at: params.expires_at,
             metadata: params.metadata
         };
-        const response = await this.http.post('/checkout', payload);
+        const response = await this.http.post('/', payload);
         return {
             id: response.payment.urn,
             object: 'checkout',
             url: response.payment.url,
             status: response.payment.summary.status,
-            amount_total: response.payment.price,
-            amount_subtotal: response.payment.price,
-            currency: 'USD',
+            amount_total: response.payment.amount,
+            amount_subtotal: response.payment.amount,
+            asset: response.payment.asset,
             items: params.items,
             created_at: response.payment.created_at,
             updated_at: response.payment.updated_at,
             expires_at: response.payment.expires_at,
-            metadata: response.payment.metadata
+            metadata: response.payment.metadata ?? void 0
         };
     }
     async retrieve(checkoutId) {

package/dist/types/checkout.d.ts

@@ -1,15 +1,15 @@
-import type { Currency, Metadata } from './common';
+import type { ASSETS, Metadata } from './common';
 import type { Customer } from './customer';
 export interface CreateCheckoutPayload {
     name: string;
     description?: string;
     image_url?: string;
-    asset: 'dUSD/6';
+    asset: ASSETS;
     payment_type: 'shopping_cart';
     items: {
         name: string;
-        price: string;
-        units: number;
+        amount: string;
+        quantity: number;
         image_url?: string;
     }[];
     redirect_url: string;
@@ -20,16 +20,18 @@ export interface CreateCheckoutResponse {
     payment: {
         urn: string;
         url: string;
-        price: number;
+        asset: ASSETS;
+        amount: number;
         image_url?: string | null;
-        metadata?: Metadata;
+        metadata?: Metadata | null;
         created_at: string;
         updated_at: string;
-        expires_at: string;
+        expires_at: string | null;
         summary: {
             status: CheckoutStatus;
         };
     };
+    url_id: string;
 }
 /**
  * Represents a single item included in a checkout.
@@ -79,11 +81,11 @@ export interface CheckoutParams {
      */
     items: CheckoutItem[];
     /**
-     * Currency used for the checkout.
+     * Asset used for the checkout.
      *
-     * @default 'USD'
+     * @default 'dUSD/6'
      */
-    currency?: Currency;
+    asset?: ASSETS;
     /**
      * URL the customer will be redirected to after a successful payment.
      */
@@ -143,9 +145,9 @@ export interface Checkout {
      */
     amount_subtotal: number;
     /**
-     * Currency used for the checkout.
+     * Asset used for the checkout.
      */
-    currency: Currency;
+    asset: ASSETS;
     /**
      * Customer associated with the checkout, if any.
      */
@@ -169,5 +171,5 @@ export interface Checkout {
     /**
      * Checkout expiration timestamp in ISO 8601 format.
      */
-    expires_at: string;
+    expires_at: string | null;
 }

package/dist/types/common.d.ts

@@ -1,4 +1,4 @@
-export type Currency = 'COP' | 'USD';
+export type ASSETS = 'COPM/2' | 'DUSD/6';
 export interface Metadata {
     [key: string]: string | number | boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bloque/payments",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Official Bloque SDK for creating and managing payments and checkouts.",
   "type": "module",
   "keywords": [