@bloque/sdk 0.0.20 → 0.0.22

package/README.md

@@ -30,10 +30,14 @@ 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
+- **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
@@ -42,17 +46,39 @@ bun add @bloque/sdk
 
 ## Quick Start
 
+### Backend (Node.js, Bun, Deno)
+
 ```typescript
 import { SDK } from '@bloque/sdk';
 import type { CreateOrgParams } from '@bloque/sdk/orgs';
 
-// Initialize the SDK (server-side only)
+// Initialize the SDK with API key (backend only)
 const bloque = new SDK({
-  apiKey: process.env.BLOQUE_API_KEY!,
+  origin: 'your-origin-name', // Required: your origin identifier
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
   mode: 'production', // or 'sandbox' for testing
+  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',
@@ -72,42 +98,161 @@ 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',
-  });
+### Frontend (Browser, React Native)
 
-  console.log('Card created:', card.urn);
-  console.log('Last four digits:', card.lastFour);
-}
+```typescript
+import { SDK } from '@bloque/sdk';
+
+// Initialize the SDK with JWT authentication
+const bloque = new SDK({
+  auth: { type: 'jwt' },
+  mode: 'production',
+  platform: 'browser', // or 'react-native'
+  // tokenStorage is optional for browser (uses localStorage by default)
+  // for react-native, provide a custom storage implementation
+});
+
+// After user registration, the SDK automatically stores the JWT
+const result = await bloque.identity.origins.register('ethereum-mainnet', {
+  assertionResult: { /* ... */ },
+  type: 'individual',
+  profile: { /* ... */ }
+});
+
+// The token is now stored and used for subsequent requests
+const alias = await bloque.identity.aliases.get('user@example.com');
 ```
 
 ## Configuration
 
 ### Initialize the SDK
 
+The SDK supports different authentication methods depending on where it's running:
+
+#### Backend Configuration (API Key)
+
+For server-side applications (Node.js, Bun, Deno):
+
+```typescript
+import { SDK } from '@bloque/sdk';
+
+const bloque = new SDK({
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!, // Your Bloque API key
+  },
+  mode: 'production', // 'sandbox' or 'production'
+  platform: 'node', // optional: 'node' | 'bun' | 'deno' (defaults to 'node')
+});
+```
+
+#### Frontend Configuration (JWT)
+
+For client-side applications (Browser, React Native):
+
 ```typescript
 import { SDK } from '@bloque/sdk';
-import type { BloqueConfig } from '@bloque/sdk';
 
+// Browser
 const bloque = new SDK({
-  apiKey: 'your-api-key-here',    // Required: Your Bloque API key
-  mode: 'sandbox',                 // Required: 'sandbox' or 'production'
+  auth: { type: 'jwt' },
+  mode: 'production',
+  platform: 'browser',
+  // tokenStorage is optional - uses localStorage by default
+});
+
+// React Native (with custom storage)
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+const bloque = new SDK({
+  auth: { type: 'jwt' },
+  mode: 'production',
+  platform: 'react-native',
+  tokenStorage: {
+    get: async () => await AsyncStorage.getItem('access_token'),
+    set: async (token: string) => await AsyncStorage.setItem('access_token', token),
+    clear: async () => await AsyncStorage.removeItem('access_token'),
+  },
 });
 ```
 
 ### Configuration Options
 
-- **`apiKey`** (string, required): Your Bloque API key
-- **`mode`** ('sandbox' | 'production', required): Environment mode
+- **`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
+  - `type: 'jwt'`: For frontend platforms
+    - Requires storing and managing JWT tokens via `tokenStorage`
+
+- **`mode`** ('sandbox' | 'production', optional): Environment mode
   - `sandbox`: For testing and development
-  - `production`: For live operations
+  - `production`: For live operations (default)
+
+- **`platform`** (string, optional): Execution platform
+  - Backend: `'node'` (default) | `'bun'` | `'deno'`
+  - Frontend: `'browser'` | `'react-native'`
+  - Determines available authentication methods
+
+- **`tokenStorage`** (object, optional): JWT token storage mechanism
+  - Required for JWT authentication on non-browser platforms
+  - 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 |
+|----------|--------------|----------|---------------|
+| `node` | ✅ | ✅ | Required for JWT |
+| `bun` | ✅ | ✅ | Required for JWT |
+| `deno` | ✅ | ✅ | Required for JWT |
+| `browser` | ❌ | ✅ | Optional (uses localStorage) |
+| `react-native` | ❌ | ✅ | Required |
 
 ## API Reference
 
@@ -118,7 +263,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**:
@@ -182,8 +331,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',
 });
 ```
 
@@ -262,8 +415,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
 });
 ```
@@ -306,7 +463,152 @@ interface CardAccount {
 
 ### Identity
 
-The identity resource allows you to retrieve user aliases (alternative identifiers like email or phone).
+The identity resource allows you to register identities, retrieve user aliases, and manage authentication origins.
+
+#### Register Identity
+
+Register a new user or business identity to an authentication origin. Supports individual users (KYC) and businesses (KYB):
+
+```typescript
+// Register individual user
+const individual = await bloque.identity.origins.register('ethereum-mainnet', {
+  assertionResult: {
+    alias: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
+    challengeType: 'SIGNING_CHALLENGE',
+    value: {
+      signature: '0x1234567890abcdef...',
+      alias: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6'
+    }
+  },
+  type: 'individual',
+  profile: {
+    firstName: 'John',
+    lastName: 'Doe',
+    email: 'john@example.com'
+  }
+});
+
+// Register business
+const business = await bloque.identity.origins.register('bloque-api', {
+  assertionResult: {
+    alias: 'business-123',
+    challengeType: 'API_KEY',
+    value: {
+      apiKey: 'sk_live_abc123',
+      alias: 'business-123'
+    }
+  },
+  type: 'business',
+  profile: {
+    legalName: 'Acme Corporation',
+    name: 'Acme Corp',
+    taxId: '12-3456789',
+    type: 'LLC',
+    incorporationDate: '2020-01-15',
+    addressLine1: '123 Business St',
+    city: 'New York',
+    state: 'NY',
+    postalCode: '10001',
+    country: 'United States'
+  }
+});
+```
+
+**Parameters**:
+
+```typescript
+// Registration parameters (discriminated union by type)
+type RegisterParams = IndividualRegisterParams | BusinessRegisterParams;
+
+interface IndividualRegisterParams {
+  assertionResult: AssertionResult;
+  extraContext?: Record<string, unknown>;
+  type: 'individual';
+  profile: UserProfile;
+}
+
+interface BusinessRegisterParams {
+  assertionResult: AssertionResult;
+  extraContext?: Record<string, unknown>;
+  type: 'business';
+  profile: BusinessProfile;
+}
+
+// Assertion result for challenge verification
+interface AssertionResult {
+  alias: string;                                  // Identity identifier
+  challengeType: 'SIGNING_CHALLENGE' | 'API_KEY' | 'OAUTH_REDIRECT' | 'WEBAUTHN' | 'OTP' | 'PASSWORD';
+  value: {
+    signature?: string;                           // For SIGNING_CHALLENGE
+    apiKey?: string;                              // For API_KEY
+    alias: string;
+  };
+  originalChallengeParams?: {
+    challenge: string;
+    timestamp: number;
+  };
+}
+
+// Individual user profile (KYC)
+interface UserProfile {
+  firstName?: string;
+  lastName?: string;
+  birthdate?: string;                             // ISO 8601 (YYYY-MM-DD)
+  email?: string;
+  phone?: string;
+  gender?: string;
+  addressLine1?: string;
+  addressLine2?: string;
+  city?: string;
+  state?: string;
+  postalCode?: string;
+  neighborhood?: string;
+  countryOfBirthCode?: string;
+  countryOfResidenceCode?: string;
+  personalIdType?: string;
+  personalIdNumber?: string;
+}
+
+// Business profile (KYB)
+interface BusinessProfile {
+  // Required fields
+  addressLine1: string;
+  city: string;
+  country: string;
+  incorporationDate: string;
+  legalName: string;
+  name: string;
+  postalCode: string;
+  state: string;
+  taxId: string;
+  type: string;
+
+  // Optional fields
+  addressLine2?: string;
+  countryCode?: string;
+  email?: string;
+  logo?: string;
+  phone?: string;
+
+  // Beneficial owner information
+  ownerName?: string;
+  ownerIdType?: string;
+  ownerIdNumber?: string;
+  ownerAddressLine1?: string;
+  ownerCity?: string;
+  ownerState?: string;
+  ownerPostalCode?: string;
+  ownerCountryCode?: string;
+}
+```
+
+**Response**:
+
+```typescript
+interface RegisterResult {
+  accessToken: string;  // JWT access token for authenticated sessions
+}
+```
 
 #### Get Alias
 
@@ -357,7 +659,10 @@ import type { CreateOrgParams } from '@bloque/sdk/orgs';
 
 // Initialize SDK with your API key
 const bloque = new SDK({
-  apiKey: process.env.BLOQUE_API_KEY!,
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
   mode: 'production',
 });
 
@@ -399,7 +704,10 @@ import { SDK } from '@bloque/sdk';
 import type { CreateOrgParams } from '@bloque/sdk/orgs';
 
 const bloque = new SDK({
-  apiKey: process.env.BLOQUE_API_KEY!,
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
   mode: 'sandbox',
 });
 
@@ -428,7 +736,10 @@ import { SDK } from '@bloque/sdk';
 import type { CreateOrgParams } from '@bloque/sdk/orgs';
 
 const bloque = new SDK({
-  apiKey: process.env.BLOQUE_API_KEY!,
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
   mode: 'production',
 });
 
@@ -476,7 +787,10 @@ import { SDK } from '@bloque/sdk';
 import type { KycVerificationParams } from '@bloque/sdk/compliance';
 
 const bloque = new SDK({
-  apiKey: process.env.BLOQUE_API_KEY!,
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
   mode: 'production',
 });
 
@@ -506,7 +820,10 @@ import { SDK } from '@bloque/sdk';
 import type { GetKycVerificationParams } from '@bloque/sdk/compliance';
 
 const bloque = new SDK({
-  apiKey: process.env.BLOQUE_API_KEY!,
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
   mode: 'production',
 });
 
@@ -541,7 +858,10 @@ import { SDK } from '@bloque/sdk';
 import type { CreateCardParams } from '@bloque/sdk/accounts';
 
 const bloque = new SDK({
-  apiKey: process.env.BLOQUE_API_KEY!,
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
   mode: 'production',
 });
 
@@ -577,7 +897,10 @@ try {
 import { SDK } from '@bloque/sdk';
 
 const bloque = new SDK({
-  apiKey: process.env.BLOQUE_API_KEY!,
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
   mode: 'production',
 });
 
@@ -610,6 +933,134 @@ try {
 }
 ```
 
+### Registering Individual User Identity (KYC)
+
+```typescript
+import { SDK } from '@bloque/sdk';
+import type { IndividualRegisterParams } from '@bloque/sdk/identity';
+
+const bloque = new SDK({
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
+  mode: 'production',
+});
+
+// Register an individual with blockchain signature
+const params: IndividualRegisterParams = {
+  assertionResult: {
+    alias: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
+    challengeType: 'SIGNING_CHALLENGE',
+    value: {
+      signature: '0x1234567890abcdef...',
+      alias: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6'
+    },
+    originalChallengeParams: {
+      challenge: 'bloque-challenge-1234567890',
+      timestamp: 1640995200
+    }
+  },
+  type: 'individual',
+  profile: {
+    firstName: 'John',
+    lastName: 'Doe',
+    email: 'john.doe@example.com',
+    phone: '+1234567890',
+    birthdate: '1990-01-15',
+    city: 'New York',
+    state: 'NY',
+    postalCode: '10001',
+    addressLine1: '123 Main St',
+    countryOfBirthCode: 'USA',
+    countryOfResidenceCode: 'USA',
+    personalIdType: 'SSN',
+    personalIdNumber: '123-45-6789'
+  }
+};
+
+try {
+  const result = await bloque.identity.origins.register('ethereum-mainnet', params);
+
+  console.log('User registered successfully!');
+  console.log('Access token:', result.accessToken);
+
+  // Store the access token securely for the user's session
+  // Use it for subsequent authenticated API calls
+} catch (error) {
+  console.error('Registration failed:', error);
+}
+```
+
+### Registering Business Identity (KYB)
+
+```typescript
+import { SDK } from '@bloque/sdk';
+import type { BusinessRegisterParams } from '@bloque/sdk/identity';
+
+const bloque = new SDK({
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
+  mode: 'production',
+});
+
+// Register a business with API key authentication
+const params: BusinessRegisterParams = {
+  assertionResult: {
+    alias: 'business-123',
+    challengeType: 'API_KEY',
+    value: {
+      apiKey: 'sk_live_abc123def456',
+      alias: 'business-123'
+    }
+  },
+  type: 'business',
+  profile: {
+    // Required business information
+    legalName: 'Acme Corporation',
+    name: 'Acme Corp',
+    taxId: '12-3456789',
+    type: 'LLC',
+    incorporationDate: '2020-01-15',
+    addressLine1: '123 Business St',
+    city: 'New York',
+    state: 'NY',
+    postalCode: '10001',
+    country: 'United States',
+
+    // Optional business information
+    addressLine2: 'Suite 100',
+    countryCode: 'US',
+    email: 'contact@acme.com',
+    phone: '+1-555-0123',
+    logo: 'https://acme.com/logo.png',
+
+    // Beneficial owner information (for compliance)
+    ownerName: 'Jane Smith',
+    ownerIdType: 'SSN',
+    ownerIdNumber: '123-45-6789',
+    ownerAddressLine1: '456 Owner Ave',
+    ownerCity: 'New York',
+    ownerState: 'NY',
+    ownerPostalCode: '10002',
+    ownerCountryCode: 'US'
+  }
+};
+
+try {
+  const result = await bloque.identity.origins.register('bloque-api', params);
+
+  console.log('Business registered successfully!');
+  console.log('Access token:', result.accessToken);
+
+  // Use the access token for authenticated API calls
+} catch (error) {
+  console.error('Business registration failed:', error);
+}
+```
+
 ### Using in an API Endpoint
 
 ```typescript
@@ -617,7 +1068,10 @@ import { SDK } from '@bloque/sdk';
 import type { CreateOrgParams } from '@bloque/sdk/orgs';
 
 const bloque = new SDK({
-  apiKey: process.env.BLOQUE_API_KEY!,
+  auth: {
+    type: 'apiKey',
+    apiKey: process.env.BLOQUE_API_KEY!,
+  },
   mode: process.env.NODE_ENV === 'production' ? 'production' : 'sandbox',
 });
 
@@ -765,6 +1219,13 @@ import type {
 // Identity types
 import type {
   Alias,
+  RegisterParams,
+  IndividualRegisterParams,
+  BusinessRegisterParams,
+  RegisterResult,
+  UserProfile,
+  BusinessProfile,
+  AssertionResult,
 } from '@bloque/sdk/identity';
 ```
 

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,_=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 this.httpClient.config.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,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 this.httpClient.config.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.20",
+  "version": "0.0.22",
   "description": "Official Bloque SDK",
   "type": "module",
   "keywords": [
@@ -63,10 +63,10 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@bloque/sdk-accounts": "0.0.20",
-    "@bloque/sdk-compliance": "0.0.20",
-    "@bloque/sdk-core": "0.0.20",
-    "@bloque/sdk-identity": "0.0.20",
-    "@bloque/sdk-orgs": "0.0.20"
+    "@bloque/sdk-accounts": "0.0.22",
+    "@bloque/sdk-compliance": "0.0.22",
+    "@bloque/sdk-core": "0.0.22",
+    "@bloque/sdk-identity": "0.0.22",
+    "@bloque/sdk-orgs": "0.0.22"
   }
 }