@notabene/javascript-sdk 2.9.0-next.1 → 2.9.0-next.3

package/src/utils/__tests__/connections.test.ts

@@ -1,7 +1,12 @@
 import fc from 'fast-check';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import type { DID } from '../../types';
-import { ConnectionManager, TransactionType } from '../connections';
+import type { DID, RefreshSource } from '../../types';
+import {
+  ConnectionManager,
+  ConnectionStatus,
+  getRefreshResult,
+  TransactionType,
+} from '../connections';
 import { seal } from '../encryption';
 
 // Mock fetch globally
@@ -13,30 +18,32 @@ const arbDID = fc
   .tuple(fc.string(), fc.string())
   .map(([method, id]) => `did:${method}:${id}` as DID);
 
+const arbTx = fc.record({
+  requestId: fc.option(fc.uuid(), { nil: undefined }),
+  customer: fc.option(
+    fc.record({
+      name: fc.string(),
+      email: fc.option(fc.string(), { nil: undefined }),
+      phone: fc.option(fc.string(), { nil: undefined }),
+      type: fc.constant(undefined), // Optional PersonType
+      accountNumber: fc.option(fc.string(), { nil: undefined }),
+      did: fc.option(arbDID, { nil: undefined }),
+      verified: fc.option(fc.boolean(), { nil: undefined }),
+      website: fc.option(fc.webUrl(), { nil: undefined }),
+      geographicAddress: fc.option(fc.constant(undefined), {
+        nil: undefined,
+      }),
+      nationalIdentification: fc.option(fc.constant(undefined), {
+        nil: undefined,
+      }),
+    }),
+    { nil: undefined },
+  ),
+});
+
 // Test helper to create arbitrary ComponentRequests
 const arbComponentRequest = fc.record({
-  tx: fc.record({
-    requestId: fc.option(fc.uuid(), { nil: undefined }),
-    customer: fc.option(
-      fc.record({
-        name: fc.string(),
-        email: fc.option(fc.string(), { nil: undefined }),
-        phone: fc.option(fc.string(), { nil: undefined }),
-        type: fc.constant(undefined), // Optional PersonType
-        accountNumber: fc.option(fc.string(), { nil: undefined }),
-        did: fc.option(arbDID, { nil: undefined }),
-        verified: fc.option(fc.boolean(), { nil: undefined }),
-        website: fc.option(fc.webUrl(), { nil: undefined }),
-        geographicAddress: fc.option(fc.constant(undefined), {
-          nil: undefined,
-        }),
-        nationalIdentification: fc.option(fc.constant(undefined), {
-          nil: undefined,
-        }),
-      }),
-      { nil: undefined },
-    ),
-  }),
+  tx: arbTx,
   authToken: fc.option(fc.string(), { nil: undefined }),
   txOptions: fc.option(fc.record({}), { nil: undefined }),
 });
@@ -68,6 +75,7 @@ describe('ConnectionManager', () => {
             const mockResponse = {
               id: 'test-id',
               version: 1,
+              status: 'active',
               metadata,
               sealed: ['encrypted-data'],
             };
@@ -92,6 +100,7 @@ describe('ConnectionManager', () => {
             expect(result).toEqual({
               id: mockResponse.id,
               metadata: mockResponse.metadata,
+              status: mockResponse.status,
               version: mockResponse.version,
               data: request,
               key: expect.any(String),
@@ -124,6 +133,9 @@ describe('ConnectionManager', () => {
 
   describe('update', () => {
     it('should successfully update an existing connection', async () => {
+      const testData = { requestId: 'test-123' };
+      const sealed = await seal(testData);
+
       await fc.assert(
         fc.asyncProperty(
           fc.uuid(),
@@ -134,8 +146,9 @@ describe('ConnectionManager', () => {
             const mockResponse = {
               id,
               metadata: arbConnectionMetadata,
+              status: 'completed',
               version: version + 1,
-              sealed: ['new-encrypted-data'],
+              sealed: [sealed.ciphertext],
             };
 
             fetchMock.mockResolvedValueOnce({
@@ -143,7 +156,13 @@ describe('ConnectionManager', () => {
               json: async () => mockResponse,
             });
 
-            const result = await manager.update(id, request, version);
+            const result = await manager.update(
+              id,
+              request,
+              version,
+              'completed',
+              sealed.key,
+            );
 
             // Verify fetch was called correctly
             expect(fetchMock).toHaveBeenCalledWith(`${testEndpoint}/${id}`, {
@@ -158,16 +177,19 @@ describe('ConnectionManager', () => {
             expect(result).toEqual({
               id: mockResponse.id,
               version: mockResponse.version,
+              status: mockResponse.status,
               metadata: mockResponse.metadata,
               data: request,
-              key: expect.any(String),
+              key: sealed.key,
             });
           },
         ),
       );
     });
 
-    it('should throw error on failed update', async () => {
+    it('should throw error on failed update due to invalid key', async () => {
+      const { key: newKey } = await seal('testData');
+
       await fc.assert(
         fc.asyncProperty(
           fc.uuid(),
@@ -180,9 +202,9 @@ describe('ConnectionManager', () => {
               text: async () => 'Update failed',
             });
 
-            await expect(manager.update(id, request, version)).rejects.toThrow(
-              'Failed to update connection',
-            );
+            await expect(
+              manager.update(id, request, version, 'active', newKey),
+            ).rejects.toThrow('Failed to update connection');
           },
         ),
       );
@@ -201,6 +223,7 @@ describe('ConnectionManager', () => {
           const mockResponse = {
             id,
             version: 1,
+            status: 'active',
             metadata: arbConnectionMetadata,
             sealed: [sealed.ciphertext], // Use the real ciphertext
           };
@@ -221,6 +244,7 @@ describe('ConnectionManager', () => {
           expect(result).toEqual({
             id: mockResponse.id,
             version: mockResponse.version,
+            status: mockResponse.status,
             metadata: mockResponse.metadata,
             data: testData, // Should match our original test data
             key: sealed.key,
@@ -281,4 +305,133 @@ describe('ConnectionManager', () => {
       );
     });
   });
+
+  describe('getRefreshResult', async () => {
+    // Create test data and sealed object
+    const tx = { requestId: 'test-123' };
+    const result = { txCreate: { requestId: 'test-123' } };
+    const testData = { tx, result };
+    const sealed = await seal(testData);
+
+    // Create a refresh source with the real key
+    const refreshSource: RefreshSource = {
+      url: 'https://test-endpoint.com',
+      key: sealed.key,
+    };
+
+    // Common metadata for all tests
+    const metadata = {
+      participants: ['participant1'],
+      nodeUrl: 'https://node-url.com',
+      transactionType: 'withdraw' as TransactionType,
+    };
+
+    // Helper function to create mock responses
+    const createMockResponse = (
+      status: ConnectionStatus,
+      sealedData = sealed.ciphertext,
+    ) => ({
+      id: 'test-id',
+      metadata,
+      status,
+      sealed: [sealedData],
+      version: 1,
+    });
+
+    it('should return basic data for closed status', async () => {
+      const mockResponse = createMockResponse('closed');
+
+      fetchMock.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      });
+
+      const result = await getRefreshResult(refreshSource);
+
+      expect(result).toEqual({
+        id: mockResponse.id,
+        metadata: mockResponse.metadata,
+        status: 'closed',
+      });
+    });
+
+    it('should return data with tx for active status', async () => {
+      const mockResponse = createMockResponse('active');
+
+      fetchMock.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      });
+
+      const result = await getRefreshResult(refreshSource);
+
+      expect(result).toEqual({
+        id: mockResponse.id,
+        metadata: mockResponse.metadata,
+        status: 'active',
+        tx,
+      });
+    });
+
+    it('should return data with result for completed status', async () => {
+      // Create sealed data with a result
+      const transactionResponse = { success: true, data: { id: 'test-id' } };
+      const completedSealed = await seal({
+        tx: testData,
+        result: transactionResponse,
+      });
+
+      // Create a refresh source with the new key
+      const completedRefreshSource: RefreshSource = {
+        url: 'https://test-endpoint.com',
+        key: completedSealed.key,
+      };
+
+      const mockResponse = createMockResponse(
+        'completed',
+        completedSealed.ciphertext,
+      );
+
+      fetchMock.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      });
+
+      const result = await getRefreshResult(completedRefreshSource);
+
+      expect(result).toEqual({
+        id: mockResponse.id,
+        metadata: mockResponse.metadata,
+        status: 'completed',
+        result: transactionResponse,
+      });
+    });
+
+    it('should throw error when no sealed data is present', async () => {
+      fetchMock.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          id: 'test-id',
+          metadata,
+          status: 'active' as ConnectionStatus,
+          sealed: null,
+        }),
+      });
+
+      await expect(getRefreshResult(refreshSource)).rejects.toThrow(
+        'Data missing from server response',
+      );
+    });
+
+    it('should throw error on failed request', async () => {
+      fetchMock.mockResolvedValueOnce({
+        ok: false,
+        text: async () => 'Request failed',
+      });
+
+      await expect(getRefreshResult(refreshSource)).rejects.toThrow(
+        'Failed to get connection',
+      );
+    });
+  });
 });

package/src/utils/connections.ts

@@ -1,11 +1,19 @@
-import type { ComponentRequest, TransactionOptions, UUID } from '../types';
+import type {
+  ComponentRequest,
+  RefreshSource,
+  TransactionOptions,
+  TransactionResponse,
+  UUID,
+} from '../types';
 import { seal, unseal } from './encryption';
 
 export type TransactionType = 'withdraw' | 'deposit';
+export type ConnectionStatus = 'active' | 'completed' | 'closed';
 export interface ConnectionData<T extends ComponentRequest> {
   tx: T;
   authToken?: string;
   txOptions?: TransactionOptions;
+  result?: TransactionResponse<T>;
 }
 
 export interface ConnectionMetadata {
@@ -16,11 +24,69 @@ export interface ConnectionMetadata {
 export interface ConnectionResponse<T extends ComponentRequest> {
   id: UUID;
   version: number;
+  status: ConnectionStatus;
   metadata: ConnectionMetadata;
   data: ConnectionData<T>;
   key: string;
 }
 
+export interface ConnectionResult<T extends ComponentRequest> {
+  id: UUID;
+  metadata: ConnectionMetadata;
+  status: ConnectionStatus;
+  tx?: T;
+  result?: TransactionResponse<T>;
+}
+
+export async function getRefreshResult<T extends ComponentRequest>(
+  refreshSource: RefreshSource,
+): Promise<ConnectionResult<T>> {
+  const response = await fetch(refreshSource.url, {
+    method: 'GET',
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to get connection: ${await response.text()}`);
+  }
+
+  const result = await response.json();
+
+  if (!result.id || !result.metadata || !result.status || !result.sealed) {
+    throw new Error('Data missing from server response');
+  }
+
+  const basicData = {
+    id: result.id,
+    metadata: result.metadata,
+    status: result.status,
+  };
+
+  if (result.status === 'closed') {
+    return basicData;
+  }
+
+  // Get the latest sealed data
+  const latestSealed = result.sealed[result.sealed.length - 1];
+
+  // Decrypt the data
+  const data = await unseal<ConnectionData<T>>({
+    ciphertext: latestSealed,
+    key: refreshSource.key,
+  });
+
+  if (result.status === 'completed') {
+    return {
+      ...basicData,
+      result: data.result,
+    };
+  }
+
+  return {
+    ...basicData,
+    tx: data.tx,
+  };
+}
+
 /**
  * Manages encrypted connections using Cloudflare Durable Objects
  */
@@ -68,6 +134,7 @@ export class ConnectionManager {
     return {
       id: result.id,
       version: result.version,
+      status: result.status,
       metadata: metadata,
       data: data,
       key: sealed.key,
@@ -85,14 +152,17 @@ export class ConnectionManager {
     id: UUID,
     data: ConnectionData<T>,
     version: number,
+    status: ConnectionStatus,
+    key: string,
   ): Promise<ConnectionResponse<T>> {
     // Encrypt the new data
-    const sealed = await seal(data);
+    const sealed = await seal(data, key);
 
     // Prepare the request body
     const body = {
       sealed: sealed.ciphertext,
       version,
+      status,
     };
 
     // Update the connection
@@ -114,6 +184,7 @@ export class ConnectionManager {
       id: result.id,
       metadata: result.metadata,
       version: result.version,
+      status: result.status,
       data: data,
       key: sealed.key,
     };
@@ -151,6 +222,7 @@ export class ConnectionManager {
 
     return {
       id: result.id,
+      status: result.status,
       version: result.version,
       metadata: result.metadata,
       data,

package/src/utils/encryption.ts

@@ -14,13 +14,15 @@ export interface Sealed {
  * @param data Data to encrypt
  * @returns Promise resolving to a Sealed object containing ciphertext and key
  */
-export async function seal<T>(data: T): Promise<Sealed> {
+export async function seal<T>(data: T, existingKey?: string): Promise<Sealed> {
   // Convert the object to a JSON string
   const plaintext = JSON.stringify(data);
   const encoder = new TextEncoder();
 
-  // Generate a random encryption key and IV
-  const rawKey = crypto.getRandomValues(new Uint8Array(32)); // 256-bit key
+  // Restore or generate a random encryption key
+  const rawKey = existingKey
+    ? base64ToUint8Array(existingKey)
+    : crypto.getRandomValues(new Uint8Array(32));
   const key = await crypto.subtle.importKey(
     'raw',
     rawKey,