@bloque/sdk 0.0.21 → 0.0.23

package/README.md

@@ -30,11 +30,15 @@ This SDK is compatible with multiple JavaScript runtimes:
 
 - **TypeScript First**: Built with TypeScript for complete type safety
 - **Simple API**: Intuitive interface for managing organizations, compliance, accounts, and identity
+- **Virtual Cards**: Create and manage virtual cards with real-time balance tracking
 - **Identity Registration**: Register individual users (KYC) and businesses (KYB) with multi-method authentication
+- **User Sessions**: Secure user session management with `connect()` for authenticated operations
 - **Fully Async**: Promise-based API for modern JavaScript workflows
 - **Lightweight**: Minimal dependencies for optimal bundle size
 - **Modular**: Import only what you need with tree-shakeable exports
 
+> **📌 Important:** Most operations require connecting to a user session first using `bloque.connect(urn)`. This ensures proper authentication and authorization. See the [User Sessions](#user-sessions-with-connect) section for details.
+
 ## Installation
 
 ```bash
@@ -51,6 +55,7 @@ import type { CreateOrgParams } from '@bloque/sdk/orgs';
 
 // Initialize the SDK with API key (backend only)
 const bloque = new SDK({
+  origin: 'your-origin-name', // Required: your origin identifier
   auth: {
     type: 'apiKey',
     apiKey: process.env.BLOQUE_API_KEY!,
@@ -59,7 +64,22 @@ const bloque = new SDK({
   platform: 'node', // optional: 'node' | 'bun' | 'deno'
 });
 
-// Create an organization
+// Connect to user session for account operations
+async function createCard() {
+  // First, connect to the user's session
+  const userSession = await bloque.connect('did:bloque:your-origin:user-alias');
+
+  // Now create a virtual card through the session
+  const card = await userSession.accounts.card.create({
+    urn: 'did:bloque:your-origin:user-alias',
+    name: 'My Virtual Card',
+  });
+
+  console.log('Card created:', card.urn);
+  console.log('Last four digits:', card.lastFour);
+}
+
+// Create an organization (direct SDK access, no connect needed)
 async function createOrganization() {
   const params: CreateOrgParams = {
     org_type: 'business',
@@ -79,20 +99,10 @@ async function createOrganization() {
     },
   };
 
-  const organization = await bloque.orgs.create(params);
+  const userSession = await bloque.connect('did:bloque:your-origin:user-alias');
+  const organization = await userSession.orgs.create(params);
   console.log('Organization created:', organization);
 }
-
-// Create a virtual card
-async function createCard() {
-  const card = await bloque.accounts.card.create({
-    urn: 'did:bloque:user:123e4567',
-    name: 'My Virtual Card',
-  });
-
-  console.log('Card created:', card.urn);
-  console.log('Last four digits:', card.lastFour);
-}
 ```
 
 ### Frontend (Browser, React Native)
@@ -175,6 +185,10 @@ const bloque = new SDK({
 
 ### Configuration Options
 
+- **`origin`** (string, required): Your origin identifier/namespace
+  - This identifies your application or organization in the Bloque platform
+  - Example: `'my-app'`, `'bloque-root'`, `'ethereum-mainnet'`
+
 - **`auth`** (object, required): Authentication configuration
   - `type: 'apiKey'`: For backend platforms
     - `apiKey` (string, required): Your Bloque API key
@@ -195,6 +209,42 @@ const bloque = new SDK({
   - Browser automatically uses `localStorage` if not provided
   - Must implement: `get()`, `set(token)`, `clear()`
 
+### User Sessions with `connect()`
+
+Most operations in the SDK require connecting to a user session first. This ensures proper authentication and authorization for user-specific operations.
+
+```typescript
+// Initialize SDK
+const bloque = new SDK({
+  origin: 'your-origin',
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
+  mode: 'production',
+});
+
+// Connect to user session
+const userSession = await bloque.connect('did:bloque:your-origin:user-alias');
+
+// Now perform operations through the session
+const card = await userSession.accounts.card.create({
+  urn: 'did:bloque:your-origin:user-alias',
+  name: 'My Card',
+});
+```
+
+**What `connect()` does:**
+- Authenticates the user with the specified URN
+- Obtains an access token for the user session
+- Returns a session object with access to: `accounts`, `compliance`, `identity`, `orgs`
+
+**URN Format:**
+- Pattern: `did:bloque:{origin}:{user-alias}`
+- Example: `did:bloque:my-app:john-doe`
+- The `{origin}` must match the origin specified in SDK configuration
+- The `{user-alias}` is the user's unique identifier in your origin
+
 ### Platform and Authentication Compatibility
 
 | Platform | API Key Auth | JWT Auth | Token Storage |
@@ -214,7 +264,11 @@ The organizations resource allows you to create and manage organizations in the
 #### Create an Organization
 
 ```typescript
-const organization = await bloque.orgs.create(params);
+// Connect to user session first
+const userSession = await bloque.connect('did:bloque:your-origin:user-alias');
+
+// Create organization through the session
+const organization = await userSession.orgs.create(params);
 ```
 
 **Parameters**:
@@ -278,8 +332,12 @@ The compliance resource provides KYC (Know Your Customer) verification functiona
 Start a KYC verification process for a user:
 
 ```typescript
-const verification = await bloque.compliance.kyc.startVerification({
-  urn: 'did:bloque:origin:user-id',
+// Connect to user session
+const userSession = await bloque.connect('did:bloque:your-origin:user-alias');
+
+// Start KYC verification
+const verification = await userSession.compliance.kyc.startVerification({
+  urn: 'did:bloque:your-origin:user-alias',
 });
 ```
 
@@ -358,8 +416,12 @@ The accounts resource allows you to create virtual cards for users.
 Create a virtual card for a user:
 
 ```typescript
-const card = await bloque.accounts.card.create({
-  urn: 'did:bloque:user:123e4567',
+// Connect to user session
+const userSession = await bloque.connect('did:bloque:your-origin:user-alias');
+
+// Create virtual card
+const card = await userSession.accounts.card.create({
+  urn: 'did:bloque:your-origin:user-alias',
   name: 'My Virtual Card', // Optional
 });
 ```
@@ -397,9 +459,263 @@ interface CardAccount {
   metadata?: Record<string, unknown>; // Custom metadata
   createdAt: string;              // Creation timestamp (ISO 8601)
   updatedAt: string;              // Last update timestamp (ISO 8601)
+  balance?: Record<string, TokenBalance>; // Token balances (only in list responses)
+}
+
+interface TokenBalance {
+  current: string;  // Current balance
+  pending: string;  // Pending balance
+  in: string;       // Total incoming
+  out: string;      // Total outgoing
+}
+```
+
+#### List Card Accounts
+
+List all card accounts for a holder with their current balances:
+
+```typescript
+// Using connected user session (recommended)
+const userSession = await bloque.connect('did:bloque:your-origin:user-alias');
+const cards = await userSession.accounts.card.list();
+
+// Or with explicit holder URN
+const cards = await bloque.accounts.card.list({
+  holderUrn: 'did:bloque:bloque-whatsapp:573023348486',
+});
+```
+
+**Parameters**:
+
+```typescript
+interface ListCardParams {
+  /**
+   * URN of the account holder to filter by
+   * Optional when using a connected session - defaults to session URN
+   * @example "did:bloque:bloque-whatsapp:573023348486"
+   */
+  holderUrn?: string;
+}
+```
+
+**Response**: `Promise<CardAccount[]>` - Array of card accounts with balances
+
+Each card in the response includes all standard fields plus a `balance` object containing token balances with current, pending, in, and out amounts for each token.
+
+#### Get Card Balance
+
+Get the current balance for a specific card account:
+
+```typescript
+const balances = await bloque.accounts.card.balance({
+  urn: 'did:bloque:account:card:usr-123:crd-456',
+});
+```
+
+**Parameters**:
+
+```typescript
+interface GetBalanceParams {
+  /**
+   * URN of the card account
+   * @example "did:bloque:account:card:usr-123:crd-456"
+   */
+  urn: string;
+}
+```
+
+**Response**: `Promise<Record<string, TokenBalance>>` - Token balances by asset
+
+Returns an object with token balances for each asset:
+
+```typescript
+{
+  'DUSD/6': {
+    current: '1262500',  // Current balance
+    pending: '0',        // Pending balance
+    in: '5072000',       // Total incoming
+    out: '3809500'       // Total outgoing
+  },
+  'KSM/12': {
+    current: '1989000011',
+    pending: '0',
+    in: '2000000000',
+    out: '10999989'
+  }
+}
+```
+
+#### List Card Movements
+
+List transactions/movements for a card account with pagination and filtering:
+
+```typescript
+// Basic usage
+const movements = await bloque.accounts.card.movements({
+  urn: 'did:bloque:account:card:usr-123:crd-456',
+  asset: 'DUSD/6',
+});
+
+// With pagination and filters
+const recentIncoming = await bloque.accounts.card.movements({
+  urn: 'did:bloque:account:card:usr-123:crd-456',
+  asset: 'DUSD/6',
+  limit: 50,
+  direction: 'in', // Only incoming transactions
+  after: '2025-01-01T00:00:00Z',
+});
+```
+
+**Parameters**:
+
+```typescript
+interface ListMovementsParams {
+  /**
+   * URN of the card account
+   * @example "did:bloque:account:card:usr-123:crd-456"
+   */
+  urn: string;
+
+  /**
+   * Asset to filter transactions by
+   * Supported assets: 'DUSD/6' | 'KSM/12'
+   * Defaults to "DUSD/6" if not provided
+   * @example "DUSD/6" or "KSM/12"
+   */
+  asset?: 'DUSD/6' | 'KSM/12';
+
+  /**
+   * Maximum number of transactions to return
+   * @example 50
+   */
+  limit?: number;
+
+  /**
+   * Filter transactions before this date (ISO 8601)
+   * @example "2025-01-01T00:00:00Z"
+   */
+  before?: string;
+
+  /**
+   * Filter transactions after this date (ISO 8601)
+   * @example "2025-01-01T00:00:00Z"
+   */
+  after?: string;
+
+  /**
+   * Filter by transaction reference
+   * @example "0xbff43fa587e0efa275f8b643d95881713c0f0ee13682d049cc452f607241b752"
+   */
+  reference?: string;
+
+  /**
+   * Filter by transaction direction
+   * 'in' for incoming funds (deposits, transfers received)
+   * 'out' for outgoing funds (withdrawals, transfers sent)
+   */
+  direction?: 'in' | 'out';
+}
+```
+
+**Response**: `Promise<CardMovement[]>` - Array of card transactions
+
+Each movement includes:
+
+```typescript
+interface CardMovement {
+  amount: string;          // Transaction amount
+  asset: string;           // Asset identifier (e.g., "DUSD/6")
+  from_account_id: string; // Source account ID
+  to_account_id: string;   // Destination account ID
+  direction: 'in' | 'out'; // Transaction direction
+  reference: string;       // Blockchain transaction reference
+  rail_name: string;       // Payment rail used
+  created_at: string;      // Transaction timestamp (ISO 8601)
+
+  details: {
+    type: string;          // Transaction type (e.g., "CREDIT_ADJUSTMENT")
+    metadata: {
+      // Transaction details
+      merchant_name?: string;
+      merchant_city?: string;
+      merchant_country?: string;
+      transaction_type?: string;
+      local_amount?: string;
+      local_currency?: string;
+      usd_amount?: string;
+      card_last_four?: string;
+      // ... and more
+    };
+  };
+}
+```
+
+#### Transfer Between Accounts
+
+Transfer funds between any accounts (card, virtual, bancolombia, etc.):
+
+```typescript
+const transfer = await bloque.accounts.transfer({
+  sourceUrn: 'did:bloque:account:card:usr-123:crd-456',
+  destinationUrn: 'did:bloque:account:virtual:acc-67890',
+  amount: '1000000000000',
+  asset: 'KSM/12',
+  metadata: {
+    reference: 'payment-123',
+    note: 'Monthly subscription'
+  }
+});
+```
+
+**Parameters**:
+
+```typescript
+interface TransferParams {
+  /**
+   * URN of the source account
+   * @example "did:bloque:account:card:usr-123:crd-456"
+   */
+  sourceUrn: string;
+
+  /**
+   * URN of the destination account
+   * @example "did:bloque:account:virtual:acc-67890"
+   */
+  destinationUrn: string;
+
+  /**
+   * Amount to transfer
+   * @example "1000000000000"
+   */
+  amount: string;
+
+  /**
+   * Asset to transfer
+   * Supported assets: 'DUSD/6' | 'KSM/12'
+   * @example "KSM/12"
+   */
+  asset: 'DUSD/6' | 'KSM/12';
+
+  /**
+   * Optional metadata for the transfer
+   * @example { reference: "payment-123", note: "Monthly subscription" }
+   */
+  metadata?: Record<string, unknown>;
+}
+```
+
+**Response**: `Promise<TransferResult>` - Transfer result
+
+```typescript
+interface TransferResult {
+  queueId: string;    // Queue ID for tracking the transfer
+  status: 'queued' | 'processing' | 'completed' | 'failed';
+  message: string;    // Status message
 }
 ```
 
+The transfer is queued for signing and submission. You can track its progress using the returned `queueId`.
+
 ### Identity
 
 The identity resource allows you to register identities, retrieve user aliases, and manage authentication origins.
@@ -830,6 +1146,337 @@ try {
 }
 ```
 
+### Listing Card Accounts
+
+```typescript
+import { SDK } from '@bloque/sdk';
+
+const bloque = new SDK({
+  origin: 'your-origin',
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
+  mode: 'production',
+});
+
+// Connect to user session
+const userSession = await bloque.connect('did:bloque:bloque-whatsapp:573023348486');
+
+// List all cards for the connected user
+try {
+  const cards = await userSession.accounts.card.list();
+
+  console.log(`Found ${cards.length} card accounts`);
+
+  cards.forEach((card) => {
+    console.log('\n---');
+    console.log('Card URN:', card.urn);
+    console.log('Last Four:', card.lastFour);
+    console.log('Status:', card.status);
+    console.log('Card Name:', card.metadata?.name);
+
+    // Display balances
+    if (card.balance) {
+      console.log('Balances:');
+      Object.entries(card.balance).forEach(([token, balance]) => {
+        console.log(`  ${token}:`);
+        console.log(`    Current: ${balance.current}`);
+        console.log(`    Pending: ${balance.pending}`);
+        console.log(`    In: ${balance.in}`);
+        console.log(`    Out: ${balance.out}`);
+      });
+    }
+  });
+
+  // Find active cards only
+  const activeCards = cards.filter(card => card.status === 'active');
+  console.log(`\n${activeCards.length} cards are active`);
+
+  // Calculate total balance across all cards
+  const totalBalances: Record<string, bigint> = {};
+
+  activeCards.forEach(card => {
+    if (card.balance) {
+      Object.entries(card.balance).forEach(([token, balance]) => {
+        if (!totalBalances[token]) {
+          totalBalances[token] = BigInt(0);
+        }
+        totalBalances[token] += BigInt(balance.current);
+      });
+    }
+  });
+
+  console.log('\nTotal balances across all active cards:');
+  Object.entries(totalBalances).forEach(([token, total]) => {
+    console.log(`  ${token}: ${total.toString()}`);
+  });
+} catch (error) {
+  console.error('Failed to list cards:', error);
+}
+```
+
+### Getting Card Balance
+
+```typescript
+import { SDK } from '@bloque/sdk';
+
+const bloque = new SDK({
+  origin: 'your-origin',
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
+  mode: 'production',
+});
+
+// Get balance for a specific card
+try {
+  const balances = await bloque.accounts.card.balance({
+    urn: 'did:bloque:account:card:usr-123:crd-456',
+  });
+
+  console.log('Card Balances:\n');
+
+  Object.entries(balances).forEach(([token, balance]) => {
+    console.log(`${token}:`);
+    console.log(`  Current: ${balance.current}`);
+    console.log(`  Pending: ${balance.pending}`);
+    console.log(`  Total In: ${balance.in}`);
+    console.log(`  Total Out: ${balance.out}`);
+
+    const net = BigInt(balance.in) - BigInt(balance.out);
+    console.log(`  Net: ${net.toString()}`);
+    console.log('');
+  });
+
+  // Calculate total current balance across all assets
+  const totalCurrent = Object.entries(balances).reduce(
+    (acc, [token, balance]) => {
+      acc[token] = BigInt(balance.current);
+      return acc;
+    },
+    {} as Record<string, bigint>,
+  );
+
+  console.log('Total Current Balances:');
+  Object.entries(totalCurrent).forEach(([token, amount]) => {
+    console.log(`  ${token}: ${amount.toString()}`);
+  });
+} catch (error) {
+  console.error('Failed to get balance:', error);
+}
+```
+
+### Listing Card Movements
+
+```typescript
+import { SDK } from '@bloque/sdk';
+
+const bloque = new SDK({
+  origin: 'your-origin',
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
+  mode: 'production',
+});
+
+// List recent transactions with pagination
+try {
+  const movements = await bloque.accounts.card.movements({
+    urn: 'did:bloque:account:card:usr-123:crd-456',
+    asset: 'DUSD/6',
+    limit: 50,
+    direction: 'in', // Only incoming transactions
+    after: '2025-01-01T00:00:00Z',
+  });
+
+  console.log(`Found ${movements.length} incoming transactions\n`);
+
+  movements.forEach((transaction) => {
+    console.log('---');
+    console.log(`Amount: ${transaction.amount} ${transaction.asset}`);
+    console.log(`Direction: ${transaction.direction.toUpperCase()}`);
+    console.log(`Date: ${transaction.created_at}`);
+    console.log(`Reference: ${transaction.reference}`);
+
+    // Show merchant details if available
+    if (transaction.details?.metadata) {
+      const meta = transaction.details.metadata;
+      if (meta.merchant_name) {
+        console.log(`Merchant: ${meta.merchant_name}`);
+      }
+      if (meta.merchant_city && meta.merchant_country) {
+        console.log(`Location: ${meta.merchant_city}, ${meta.merchant_country}`);
+      }
+      if (meta.transaction_type) {
+        console.log(`Type: ${meta.transaction_type}`);
+      }
+      if (meta.usd_amount) {
+        console.log(`USD Amount: $${meta.usd_amount}`);
+      }
+    }
+    console.log('');
+  });
+
+  // Calculate total
+  const total = movements.reduce(
+    (sum, t) => sum + BigInt(t.amount),
+    BigInt(0),
+  );
+
+  console.log(`Total received: ${total.toString()}`);
+} catch (error) {
+  console.error('Failed to list movements:', error);
+}
+```
+
+### Paginating Through Card Movements
+
+```typescript
+import { SDK } from '@bloque/sdk';
+
+const bloque = new SDK({
+  origin: 'your-origin',
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
+  mode: 'production',
+});
+
+// Paginate through all transactions
+async function getAllTransactions() {
+  const cardUrn = 'did:bloque:account:card:usr-123:crd-456';
+  const pageSize = 100;
+  let allMovements = [];
+  let hasMore = true;
+  let lastDate: string | undefined;
+
+  try {
+    while (hasMore) {
+      const movements = await bloque.accounts.card.movements({
+        urn: cardUrn,
+        asset: 'DUSD/6',
+        limit: pageSize,
+        before: lastDate, // Get transactions before the last one we saw
+      });
+
+      allMovements.push(...movements);
+      console.log(`Fetched ${movements.length} transactions`);
+
+      if (movements.length < pageSize) {
+        hasMore = false; // Last page
+      } else {
+        lastDate = movements[movements.length - 1].created_at;
+      }
+    }
+
+    console.log(`\nTotal transactions: ${allMovements.length}`);
+
+    // Analyze all transactions
+    const totalIn = allMovements
+      .filter((t) => t.direction === 'in')
+      .reduce((sum, t) => sum + BigInt(t.amount), BigInt(0));
+
+    const totalOut = allMovements
+      .filter((t) => t.direction === 'out')
+      .reduce((sum, t) => sum + BigInt(t.amount), BigInt(0));
+
+    console.log(`Total incoming: ${totalIn.toString()}`);
+    console.log(`Total outgoing: ${totalOut.toString()}`);
+    console.log(`Net balance: ${(totalIn - totalOut).toString()}`);
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+
+getAllTransactions();
+```
+
+### Transferring Funds Between Accounts
+
+```typescript
+import { SDK } from '@bloque/sdk';
+
+const bloque = new SDK({
+  origin: 'your-origin',
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
+  mode: 'production',
+});
+
+// Transfer from card to virtual account
+try {
+  const transfer = await bloque.accounts.transfer({
+    sourceUrn: 'did:bloque:account:card:usr-123:crd-456',
+    destinationUrn: 'did:bloque:account:virtual:acc-67890',
+    amount: '1000000000000',
+    asset: 'KSM/12',
+    metadata: {
+      reference: 'payment-123',
+      note: 'Monthly subscription payment'
+    }
+  });
+
+  console.log('Transfer initiated:');
+  console.log('  Queue ID:', transfer.queueId);
+  console.log('  Status:', transfer.status);
+  console.log('  Message:', transfer.message);
+
+  // The transfer is now queued for processing
+  // You can track its status using the queueId
+} catch (error) {
+  console.error('Transfer failed:', error);
+}
+```
+
+### Different Transfer Scenarios
+
+```typescript
+import { SDK } from '@bloque/sdk';
+
+const bloque = new SDK({
+  origin: 'your-origin',
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
+  mode: 'production',
+});
+
+// Transfer DUSD from card to Bancolombia account
+const dusdTransfer = await bloque.accounts.transfer({
+  sourceUrn: 'did:bloque:account:card:usr-123:crd-456',
+  destinationUrn: 'did:bloque:account:bancolombia:acc-12345',
+  amount: '5000000', // 5 DUSD (6 decimals)
+  asset: 'DUSD/6',
+  metadata: {
+    reference: 'withdrawal-001',
+    type: 'savings'
+  }
+});
+
+console.log(`DUSD transfer queued: ${dusdTransfer.queueId}`);
+
+// Transfer KSM between virtual accounts
+const ksmTransfer = await bloque.accounts.transfer({
+  sourceUrn: 'did:bloque:account:virtual:acc-11111',
+  destinationUrn: 'did:bloque:account:virtual:acc-22222',
+  amount: '2000000000000', // 2 KSM (12 decimals)
+  asset: 'KSM/12',
+  metadata: {
+    reference: 'internal-transfer-42',
+    department: 'operations'
+  }
+});
+
+console.log(`KSM transfer queued: ${ksmTransfer.queueId}`);
+```
+
 ### Retrieving User Alias Information
 
 ```typescript
@@ -1152,7 +1799,14 @@ import type {
 // Accounts types
 import type {
   CardAccount,
+  CardMovement,
   CreateCardParams,
+  GetBalanceParams,
+  ListCardParams,
+  ListMovementsParams,
+  TokenBalance,
+  TransferParams,
+  TransferResult,
 } from '@bloque/sdk/accounts';
 
 // Identity types

package/dist/bloque.d.ts

@@ -5,9 +5,12 @@ import { IdentityClient } from '@bloque/sdk-identity';
 import { OrgsClient } from '@bloque/sdk-orgs';
 export declare class SDK {
     private readonly httpClient;
-    readonly accounts: AccountsClient;
-    readonly compliance: ComplianceClient;
-    readonly identity: IdentityClient;
-    readonly orgs: OrgsClient;
     constructor(config: BloqueConfig);
+    private extractUserAlias;
+    connect(urn: string): Promise<{
+        accounts: AccountsClient;
+        compliance: ComplianceClient;
+        identity: IdentityClient;
+        orgs: OrgsClient;
+    }>;
 }

package/dist/index.cjs

@@ -1 +1 @@
-"use strict";const __rslib_import_meta_url__="u"<typeof document?new(require("url".replace("",""))).URL("file:"+__filename).href:document.currentScript&&document.currentScript.src||new URL("main.js",document.baseURI).href;var __webpack_require__={};__webpack_require__.d=(e,_)=>{for(var t in _)__webpack_require__.o(_,t)&&!__webpack_require__.o(e,t)&&Object.defineProperty(e,t,{enumerable:!0,get:_[t]})},__webpack_require__.o=(e,_)=>Object.prototype.hasOwnProperty.call(e,_),__webpack_require__.r=e=>{"u">typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var __webpack_exports__={};__webpack_require__.r(__webpack_exports__),__webpack_require__.d(__webpack_exports__,{SDK:()=>SDK});const sdk_accounts_namespaceObject=require("@bloque/sdk-accounts"),sdk_compliance_namespaceObject=require("@bloque/sdk-compliance"),sdk_core_namespaceObject=require("@bloque/sdk-core"),sdk_identity_namespaceObject=require("@bloque/sdk-identity"),sdk_orgs_namespaceObject=require("@bloque/sdk-orgs");class SDK{httpClient;accounts;compliance;identity;orgs;constructor(e){this.httpClient=new sdk_core_namespaceObject.HttpClient(e),this.accounts=new sdk_accounts_namespaceObject.AccountsClient(this.httpClient),this.compliance=new sdk_compliance_namespaceObject.ComplianceClient(this.httpClient),this.identity=new sdk_identity_namespaceObject.IdentityClient(this.httpClient),this.orgs=new sdk_orgs_namespaceObject.OrgsClient(this.httpClient)}}for(var __rspack_i in exports.SDK=__webpack_exports__.SDK,__webpack_exports__)-1===["SDK"].indexOf(__rspack_i)&&(exports[__rspack_i]=__webpack_exports__[__rspack_i]);Object.defineProperty(exports,"__esModule",{value:!0});
+"use strict";const __rslib_import_meta_url__="u"<typeof document?new(require("url".replace("",""))).URL("file:"+__filename).href:document.currentScript&&document.currentScript.src||new URL("main.js",document.baseURI).href;var __webpack_require__={};__webpack_require__.d=(e,t)=>{for(var _ in t)__webpack_require__.o(t,_)&&!__webpack_require__.o(e,_)&&Object.defineProperty(e,_,{enumerable:!0,get:t[_]})},__webpack_require__.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),__webpack_require__.r=e=>{"u">typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var __webpack_exports__={};__webpack_require__.r(__webpack_exports__),__webpack_require__.d(__webpack_exports__,{SDK:()=>SDK});const sdk_accounts_namespaceObject=require("@bloque/sdk-accounts"),sdk_compliance_namespaceObject=require("@bloque/sdk-compliance"),sdk_core_namespaceObject=require("@bloque/sdk-core"),sdk_identity_namespaceObject=require("@bloque/sdk-identity"),sdk_orgs_namespaceObject=require("@bloque/sdk-orgs");class SDK{httpClient;constructor(e){this.httpClient=new sdk_core_namespaceObject.HttpClient(e)}extractUserAlias(e){let t=e.match(/^did:bloque:[^:]+:([^:]+)$/);if(!t)throw Error(`Invalid user alias URN: ${e}`);return t[1]}async connect(e){let t=this.httpClient.config;t.urn=e;let _=await this.httpClient.request({path:`/api/origins/${t.origin}/connect`,method:"POST",body:{assertion_result:{challengeType:"API_KEY",value:{api_key:"apiKey"===t.auth.type?t.auth.apiKey:"",alias:this.extractUserAlias(e)}},extra_context:{}}});return t.accessToken=_.result.access_token,{accounts:new sdk_accounts_namespaceObject.AccountsClient(this.httpClient),compliance:new sdk_compliance_namespaceObject.ComplianceClient(this.httpClient),identity:new sdk_identity_namespaceObject.IdentityClient(this.httpClient),orgs:new sdk_orgs_namespaceObject.OrgsClient(this.httpClient)}}}for(var __rspack_i in exports.SDK=__webpack_exports__.SDK,__webpack_exports__)-1===["SDK"].indexOf(__rspack_i)&&(exports[__rspack_i]=__webpack_exports__[__rspack_i]);Object.defineProperty(exports,"__esModule",{value:!0});

package/dist/index.js

@@ -1 +1 @@
-import{AccountsClient as t}from"@bloque/sdk-accounts";import{ComplianceClient as i}from"@bloque/sdk-compliance";import{HttpClient as o}from"@bloque/sdk-core";import{IdentityClient as e}from"@bloque/sdk-identity";import{OrgsClient as s}from"@bloque/sdk-orgs";class n{httpClient;accounts;compliance;identity;orgs;constructor(n){this.httpClient=new o(n),this.accounts=new t(this.httpClient),this.compliance=new i(this.httpClient),this.identity=new e(this.httpClient),this.orgs=new s(this.httpClient)}}export{n as SDK};
+import{AccountsClient as t}from"@bloque/sdk-accounts";import{ComplianceClient as e}from"@bloque/sdk-compliance";import{HttpClient as i}from"@bloque/sdk-core";import{IdentityClient as o}from"@bloque/sdk-identity";import{OrgsClient as s}from"@bloque/sdk-orgs";class n{httpClient;constructor(t){this.httpClient=new i(t)}extractUserAlias(t){let e=t.match(/^did:bloque:[^:]+:([^:]+)$/);if(!e)throw Error(`Invalid user alias URN: ${t}`);return e[1]}async connect(i){let n=this.httpClient.config;n.urn=i;let r=await this.httpClient.request({path:`/api/origins/${n.origin}/connect`,method:"POST",body:{assertion_result:{challengeType:"API_KEY",value:{api_key:"apiKey"===n.auth.type?n.auth.apiKey:"",alias:this.extractUserAlias(i)}},extra_context:{}}});return n.accessToken=r.result.access_token,{accounts:new t(this.httpClient),compliance:new e(this.httpClient),identity:new o(this.httpClient),orgs:new s(this.httpClient)}}}export{n as SDK};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bloque/sdk",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "Official Bloque SDK",
   "type": "module",
   "keywords": [
@@ -63,10 +63,10 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@bloque/sdk-accounts": "0.0.21",
-    "@bloque/sdk-compliance": "0.0.21",
-    "@bloque/sdk-core": "0.0.21",
-    "@bloque/sdk-identity": "0.0.21",
-    "@bloque/sdk-orgs": "0.0.21"
+    "@bloque/sdk-accounts": "0.0.23",
+    "@bloque/sdk-compliance": "0.0.23",
+    "@bloque/sdk-core": "0.0.23",
+    "@bloque/sdk-identity": "0.0.23",
+    "@bloque/sdk-orgs": "0.0.23"
   }
 }