@notabene/javascript-sdk 2.9.0-next.2 → 2.9.0-next.4

package/src/types.ts

@@ -312,6 +312,18 @@ export interface Wallet extends Agent {
   wallet_connect_id?: string;
 }
 
+/**
+ * A blockchain account
+ * @public
+ */
+export interface Account {
+  did?: DID;
+  blockchainAddress?: BlockchainAddress;
+  chain?: CAIP2;
+  caip10?: CAIP10;
+  identifier?: string;
+}
+
 /**
  * The counterparty of a transaction.
  * @public
@@ -496,7 +508,7 @@ type BeneficiaryFields = {
 type DepositRequestFields = {
   destination: BlockchainAddress | CAIP10;
   asset: TransactionAsset;
-  amountDecimal?: number;
+  amountDecimal: number;
   travelAddress?: TravelAddress;
   cryptoCredential?: CryptoCredential;
 };
@@ -557,6 +569,7 @@ export interface Transaction extends ComponentRequest {
     price: number;
     currency: ISOCurrency;
   };
+  account?: Account;
 }
 
 export interface RefreshSource {
@@ -780,6 +793,24 @@ export type VASPOptions = {
   searchable?: VASPSearchControl[]; // If array left empty all VASPs will be searchable
 };
 
+/**
+ * Counterparty Assist Configuration options for recipient selection
+ *
+ * @remarks
+ * Controls for each person type, whether to show the share feature or not.
+ *
+ * @public
+ */
+export type CounterpartyAssistConfig =
+  | {
+      enabled?: boolean;
+    }
+  | {
+      [key in PersonType]: {
+        enabled?: boolean;
+      };
+    };
+
 /**
  * Sections in a WithdrawalAssist screen
  *
@@ -828,6 +859,7 @@ export interface TransactionOptions {
   fields?: FieldTypes;
   vasps?: VASPOptions;
   hide?: ValidationSections[]; // You can hide a specific section of the component by listing it here
+  counterpartyAssistConfig?: CounterpartyAssistConfig;
 }
 /**
  * Component Message Type enum representing different message types that can be sent

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 }),
 });
@@ -298,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

@@ -34,7 +34,7 @@ export interface ConnectionResult<T extends ComponentRequest> {
   id: UUID;
   metadata: ConnectionMetadata;
   status: ConnectionStatus;
-  tx: T;
+  tx?: T;
   result?: TransactionResponse<T>;
 }
 
@@ -51,8 +51,18 @@ export async function getRefreshResult<T extends ComponentRequest>(
 
   const result = await response.json();
 
-  if (!result.sealed) {
-    throw new Error('No data found');
+  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
@@ -64,12 +74,16 @@ export async function getRefreshResult<T extends ComponentRequest>(
     key: refreshSource.key,
   });
 
+  if (result.status === 'completed') {
+    return {
+      ...basicData,
+      result: data.result,
+    };
+  }
+
   return {
-    id: result.id,
-    metadata: result.metadata,
-    status: result.status,
+    ...basicData,
     tx: data.tx,
-    result: data.result,
   };
 }