@notabene/javascript-sdk 2.19.0 → 2.19.1

package/package.json

@@ -10,7 +10,7 @@
   "author": "Notabene <developers@notabene.id>",
   "license": "MIT",
   "packageManager": "yarn@4.5.1",
-  "version": "2.19.0",
+  "version": "2.19.1",
   "source": "src/notabene.ts",
   "main": "dist/cjs/notabene.cjs",
   "module": "dist/esm/notabene.js",

package/src/__tests__/EmbeddedComponent.portless-message.test.ts

@@ -0,0 +1,66 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import EmbeddedComponent from '../components/EmbeddedComponent';
+
+/**
+ * Integration test (no mocks) reproducing the Banxa crash (PAY-1056):
+ *
+ *   TypeError: Cannot set properties of undefined (setting 'onmessage')
+ *
+ * Cause: Reown/WalletConnect calls `parent.postMessage(event, '*')` from
+ * inside the widget iframe without transferring a MessagePort. The SDK's
+ * message listener passed `event.ports[0]` (undefined) to `setPort()`.
+ */
+
+interface TestValue {
+  id?: string;
+}
+
+describe('EmbeddedComponent — portless postMessage (PAY-1056)', () => {
+  let container: HTMLDivElement;
+
+  beforeEach(() => {
+    container = document.createElement('div');
+    document.body.appendChild(container);
+  });
+
+  test('should not crash when iframe sends a message without ports', () => {
+    const component = new EmbeddedComponent<TestValue, unknown>(
+      'about:blank?widget=true',
+      {},
+    );
+    component.embed(container);
+
+    const iframe = container.querySelector('iframe')!;
+
+    expect(() => {
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          source: iframe.contentWindow,
+          data: { type: 'wc_sessionUpdate' },
+          ports: [],
+        }),
+      );
+    }).not.toThrow();
+  });
+
+  test('should still accept the handshake message with a port', () => {
+    const component = new EmbeddedComponent<TestValue, unknown>(
+      'about:blank?widget=true',
+      {},
+    );
+    component.embed(container);
+
+    const iframe = container.querySelector('iframe')!;
+    const channel = new MessageChannel();
+
+    expect(() => {
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          source: iframe.contentWindow,
+          data: {},
+          ports: [channel.port2],
+        }),
+      );
+    }).not.toThrow();
+  });
+});

package/src/__tests__/EmbeddedComponent.test.ts

@@ -12,6 +12,9 @@ interface TestOptions {
   currency?: string;
 }
 
+// Store callbacks for testing
+const callbacks = new Map();
+
 // Mock MessageEventManager
 vi.mock('../utils/MessageEventManager', () => {
   return {
@@ -30,9 +33,6 @@ vi.mock('../utils/MessageEventManager', () => {
   };
 });
 
-// Store callbacks for testing
-const callbacks = new Map();
-
 describe('EmbeddedComponent', () => {
   let mockParent: HTMLElement;
   let mockAppendChild: ReturnType<typeof vi.fn>;

package/src/components/EmbeddedComponent.ts

@@ -24,6 +24,7 @@ export default class EmbeddedComponent<V, O> {
   private iframe?: HTMLIFrameElement;
   private eventManager: MessageEventManager<V, O>;
   private modal?: HTMLDialogElement;
+  private messageHandler?: (event: MessageEvent) => void;
 
   /**
    * Creates an instance of EmbeddedComponent.
@@ -112,18 +113,24 @@ export default class EmbeddedComponent<V, O> {
     // this.iframe.style.backgroundColor = 'transparent';
     parent.appendChild(this.iframe);
 
-    window.addEventListener('message', (event: MessageEvent) => {
+    this.messageHandler = (event: MessageEvent) => {
       if (event.source !== this.iframe?.contentWindow) {
         return;
       }
-      // console.log('received message from iframe', event.data);
-      this.eventManager?.setPort(event.ports[0]);
-    });
+      if (event.ports[0]) {
+        this.eventManager?.setPort(event.ports[0]);
+      }
+    };
+    window.addEventListener('message', this.messageHandler);
 
     this.iframe?.contentWindow?.focus();
   }
 
   removeEmbed() {
+    if (this.messageHandler) {
+      window.removeEventListener('message', this.messageHandler);
+      this.messageHandler = undefined;
+    }
     if (this.iframe) this.iframe.remove();
   }
 
@@ -258,13 +265,15 @@ export default class EmbeddedComponent<V, O> {
       '_blank',
       'popup=true,width=600,height=600',
     );
-    window.addEventListener('message', (event: MessageEvent) => {
+    const popupMessageHandler = (event: MessageEvent) => {
       if (event.source !== popup) {
         return;
       }
-      console.log('received message from popup', event.data);
-      this.eventManager?.setPort(event.ports[0]);
-    });
+      if (event.ports[0]) {
+        this.eventManager?.setPort(event.ports[0]);
+      }
+    };
+    window.addEventListener('message', popupMessageHandler);
 
     const removeCancel = this.on(CMType.CANCEL, () => {
       popup?.close();
@@ -275,6 +284,7 @@ export default class EmbeddedComponent<V, O> {
     });
 
     return this.completion().finally(() => {
+      window.removeEventListener('message', popupMessageHandler);
       removeCancel();
       removeComplete();
     });

package/src/notabene.ts

@@ -93,11 +93,9 @@ export {
   componentResponseToIVMS101,
   componentResponseToTxCreateRequest,
   componentResponseToTxRequests,
-  componentResponseToV1TxCreateRequest,
 } from './responseTransformer';
 export type {
   ResponseToTxRequestConfig,
-  TransactionCreateRequest,
   TransactionCreateRequestV2,
   TransactionIVMS101Request,
 } from './responseTransformer';

package/src/responseTransformer/README.md

@@ -58,26 +58,6 @@ const ivms101Body = componentResponseToIVMS101(response, delegateToken, {
 });
 ```
 
-### Version 1 API (Legacy)
-
-```typescript
-import { componentResponseToV1TxCreateRequest } from '$lib/notabene-tx-transformer';
-
-withdrawal.on('complete', async (result) => {
-	const requestBody = componentResponseToV1TxCreateRequest(result.response);
-
-	// Send to your Version 1 API
-	await fetch(`${apiUrlV1}/entity/${did}/tx`, {
-		method: 'POST',
-		headers: {
-			'Content-Type': 'application/json',
-			Authorization: `Bearer ${token}`
-		},
-		body: JSON.stringify(requestBody)
-	});
-});
-```
-
 ## API
 
 ### `componentResponseToTxRequests(response, delegateToken, config?)`
@@ -127,16 +107,6 @@ Transforms a Notabene component response to IVMS101 format.
 
 **Returns:** IVMS101 formatted request body
 
-### `componentResponseToV1TxCreateRequest(response)`
-
-Transforms a Notabene component response to a V1 transaction create request.
-
-**Parameters:**
-
-- `response`: Response from the Notabene TX Create component
-
-**Returns:** V1 transaction create request body
-
 ## Module Structure
 
 ```

package/src/responseTransformer/__tests__/transformer.test.ts

@@ -333,7 +333,7 @@ describe('componentResponseToTxRequests', () => {
                   geographicAddress: [geographicAddress],
                 },
                 legalPerson: undefined,
-                accountNumber: [TEST_ORIGINATOR_ID],
+                accountNumber: [TEST_ADDRESS],
               },
             ],
           },
@@ -435,7 +435,7 @@ describe('componentResponseToTxRequests', () => {
                   },
                 },
                 legalPerson: undefined,
-                accountNumber: [TEST_BENEFICIARY_ID],
+                accountNumber: [TEST_ADDRESS],
               },
             ],
           },

package/src/responseTransformer/index.ts

@@ -9,13 +9,11 @@ export {
   componentResponseToIVMS101,
   componentResponseToTxCreateRequest,
   componentResponseToTxRequests,
-  componentResponseToV1TxCreateRequest,
 } from './transformer';
 
 // Type exports
 export {
   type ResponseToTxRequestConfig,
-  type TransactionCreateRequest,
-  type TransactionCreateRequestV2, // rename to TransactCreateRequest?
+  type TransactionCreateRequestV2,
   type TransactionIVMS101Request,
 } from './types';

package/src/responseTransformer/mappers.ts

@@ -1,11 +1,4 @@
 import type { Agent, DID } from '@taprsvp/types';
-import type {
-  Beneficiary,
-  NaturalPerson,
-  NaturalPersonName,
-  Originator,
-  Person,
-} from '../ivms';
 import {
   PersonType,
   type Deposit,
@@ -17,7 +10,6 @@ import type {
   BaseRequestConfig,
   ResponseToIVMS101RequestConfig,
   ResponseToTxCreateRequestConfig,
-  TransactionCreateRequest,
   TransactionCreateRequestV2,
   TransactionIVMS101Request,
 } from './types';
@@ -28,212 +20,6 @@ import {
   isWithdrawal,
 } from './utils';
 
-// Constants
-const DEFAULT_GEOGRAPHIC_ADDRESS = [
-  {
-    addressType: 'GEOG' as const,
-    addressLine: ['1234 Main Street'],
-    townName: 'Unknown',
-    country: 'US',
-  },
-];
-
-// Helper functions
-function parseName(fullName: string) {
-  const trimmedName = fullName.trim();
-  if (!trimmedName) {
-    return { primaryIdentifier: '', secondaryIdentifier: '' };
-  }
-
-  const parts = trimmedName.split(/\s+/);
-  const primaryIdentifier = parts[parts.length - 1];
-  const secondaryParts = parts.slice(0, -1);
-  const secondaryIdentifier =
-    secondaryParts.length > 0 ? secondaryParts.join(' ') : primaryIdentifier;
-
-  return { primaryIdentifier, secondaryIdentifier };
-}
-
-function copyIVMS(
-  type: 'originator' | 'beneficiary',
-  persons?: Person[],
-  accountNumber: string[] = ['1234567890'],
-): Originator | Beneficiary {
-  const updatedPersons = persons?.map((person) => {
-    const updatedPerson = { ...person };
-
-    if (updatedPerson.naturalPerson) {
-      updatedPerson.naturalPerson = {
-        ...updatedPerson.naturalPerson,
-        geographicAddress: DEFAULT_GEOGRAPHIC_ADDRESS,
-      };
-    }
-
-    if (updatedPerson.legalPerson) {
-      updatedPerson.legalPerson = {
-        ...updatedPerson.legalPerson,
-        geographicAddress: DEFAULT_GEOGRAPHIC_ADDRESS,
-      };
-    }
-
-    return updatedPerson;
-  });
-
-  return type === 'originator'
-    ? { originatorPersons: updatedPersons, accountNumber }
-    : { beneficiaryPersons: updatedPersons, accountNumber };
-}
-
-function hostIVMS(
-  type: 'originator' | 'beneficiary',
-  name = 'John Doe',
-): Originator | Beneficiary {
-  const { primaryIdentifier, secondaryIdentifier } = parseName(name);
-
-  const person: Person = {
-    naturalPerson: {
-      name: [
-        {
-          nameIdentifier: [
-            {
-              primaryIdentifier,
-              ...(secondaryIdentifier ? { secondaryIdentifier } : {}),
-              nameIdentifierType: 'LEGL',
-            },
-          ],
-        },
-      ] as any,
-      geographicAddress: DEFAULT_GEOGRAPHIC_ADDRESS,
-    },
-  };
-
-  return type === 'originator'
-    ? { originatorPersons: [person], accountNumber: ['1234567890'] }
-    : { beneficiaryPersons: [person], accountNumber: ['1234567890'] };
-}
-
-const wrapNameInArray = (naturalPerson: NaturalPerson): NaturalPerson => ({
-  ...naturalPerson,
-  // @ts-expect-error Preserving the original logic
-  name: naturalPerson.name
-    ? ([naturalPerson.name] as NaturalPersonName[])
-    : undefined,
-});
-
-const transformPerson = (person: Person): Person => ({
-  ...person,
-  naturalPerson: person.naturalPerson
-    ? wrapNameInArray(person.naturalPerson)
-    : undefined,
-});
-
-const transformIVMS101 = (
-  { beneficiary, originator }: IVMS101,
-  name?: string,
-  originatorEqualsBeneficiary?: boolean,
-  destination?: string,
-  operation?: 'withdrawal' | 'deposit',
-) => {
-  if (operation === 'withdrawal') {
-    const transformedBeneficiary = beneficiary && {
-      ...beneficiary,
-      ...(destination && { accountNumber: [destination] }),
-      beneficiaryPersons: beneficiary.beneficiaryPersons?.map(transformPerson),
-    };
-
-    if (
-      originatorEqualsBeneficiary &&
-      transformedBeneficiary?.beneficiaryPersons
-    ) {
-      const originator = copyIVMS(
-        'originator',
-        transformedBeneficiary?.beneficiaryPersons,
-      ) as Originator;
-
-      return {
-        beneficiary: {
-          accountNumber: originator.accountNumber,
-          beneficiaryPersons: originator.originatorPersons,
-        },
-        originator,
-      };
-    }
-
-    return {
-      beneficiary: transformedBeneficiary,
-      originator: hostIVMS('originator', name),
-    };
-  }
-
-  if (operation === 'deposit') {
-    const transformedOriginator = originator && {
-      ...(destination && { accountNumber: [destination] }),
-      originatorPersons: originator.originatorPersons?.map(transformPerson),
-    };
-
-    if (
-      originatorEqualsBeneficiary &&
-      transformedOriginator?.originatorPersons
-    ) {
-      const beneficiary = copyIVMS(
-        'beneficiary',
-        transformedOriginator?.originatorPersons,
-      ) as Beneficiary;
-
-      return {
-        originator: {
-          accountNumber: beneficiary.accountNumber,
-          originatorPersons: beneficiary.beneficiaryPersons,
-        },
-        beneficiary,
-      };
-    }
-
-    return {
-      originator: transformedOriginator,
-      beneficiary: hostIVMS('beneficiary', name),
-    };
-  }
-
-  throw new Error('Invalid operation type');
-};
-
-export function mapToV1CreateRequest(
-  withdrawal: Withdrawal,
-  payload: V1Transaction,
-  ivms101: IVMS101,
-): TransactionCreateRequest {
-  const { beneficiary, originator } = transformIVMS101(
-    ivms101,
-    withdrawal.customer?.name,
-    payload.originatorEqualsBeneficiary,
-    withdrawal.destination,
-    'withdrawal',
-  );
-
-  return {
-    transactionAsset: payload.transactionAsset,
-    transactionAmount: payload.transactionAmount,
-    beneficiaryDid: withdrawal.counterparty?.did,
-    originatorVASPdid: payload.originatorVASPdid,
-    ...(payload.beneficiaryVASPdid && !payload.beneficiaryProof
-      ? { beneficiaryVASPdid: payload.beneficiaryVASPdid }
-      : {}),
-    transactionBlockchainInfo: {
-      ...(originator?.accountNumber && { origin: originator.accountNumber[0] }),
-      ...(withdrawal.destination && { destination: withdrawal.destination }),
-    },
-    ...(payload.beneficiaryProof && {
-      beneficiaryProof: payload.beneficiaryProof,
-    }),
-    ...(beneficiary && { beneficiary }),
-    ...(originator && { originator }),
-    ...(payload.originatorEqualsBeneficiary && {
-      originatorEqualsBeneficiary: payload.originatorEqualsBeneficiary,
-    }),
-  };
-}
-
 export function mapToTransactCreateRequest(
   transaction: Withdrawal | Deposit,
   payload: V1Transaction,
@@ -311,7 +97,9 @@ export function mapToAppendPiiRequest(
   config: ResponseToIVMS101RequestConfig & Required<BaseRequestConfig>,
 ): TransactionIVMS101Request {
   if (isWithdrawal(transaction)) {
-    const beneficiaryId = config.beneficiaryId;
+    // For outgoing transfers, the beneficiary is the counterparty — use the
+    // destination blockchain address as their accountNumber.
+    const beneficiaryAccountNumber = transaction.destination;
 
     const beneficiaryPersons =
       // If counterparty type is SELF, reuse originator data for beneficiary
@@ -319,7 +107,7 @@ export function mapToAppendPiiRequest(
         ? config.originator.originatorPerson
         : // Convert all beneficiary persons from V1 to V2 format
           ivms101.beneficiary?.beneficiaryPersons?.map((person) =>
-            convertPersonToV2(person, beneficiaryId),
+            convertPersonToV2(person, beneficiaryAccountNumber),
           ) || [];
 
     return {
@@ -332,14 +120,17 @@ export function mapToAppendPiiRequest(
     };
   }
 
-  const originatorId = config.originatorId;
+  // For incoming transfers, the originator is the counterparty — use the
+  // source blockchain address as their accountNumber.
+  const source = (transaction as Deposit).source;
+  const originatorAccountNumber = Array.isArray(source) ? source[0] : source;
 
   const originatorPersons =
     transaction.counterparty?.type === PersonType.SELF && config.beneficiary
       ? config.beneficiary.beneficiaryPerson
       : // Convert all originator persons from V1 to V2 format
         ivms101.originator?.originatorPersons?.map((person) =>
-          convertPersonToV2(person, originatorId),
+          convertPersonToV2(person, originatorAccountNumber),
         ) || [];
 
   return {

package/src/responseTransformer/transformer.ts

@@ -8,18 +8,13 @@ import {
   type TransactionResponse,
   type Withdrawal,
 } from '../types';
-import {
-  mapToAppendPiiRequest,
-  mapToTransactCreateRequest,
-  mapToV1CreateRequest,
-} from './mappers';
+import { mapToAppendPiiRequest, mapToTransactCreateRequest } from './mappers';
 import type {
   BaseRequestConfig,
   DelegateToken,
   ResponseToIVMS101RequestConfig,
   ResponseToTxCreateRequestConfig,
   ResponseToTxRequestConfig,
-  TransactionCreateRequest,
   TransactionCreateRequestV2,
   TransactionIVMS101Request,
 } from './types';
@@ -147,57 +142,6 @@ export function enrichConfig(
     Required<BaseRequestConfig>;
 }
 
-/**
- * Transforms a Notabene component response to a Version 1 API request body
- *
- * @param response - The response from the Notabene TX Create component
- * @returns The transformed request body ready for the Version 1 API
- *
- * @example
- * ```typescript
- * import { componentResponseToV1TxCreateRequest } from '$lib/notabene-tx-transformer';
- *
- * withdrawal.on('complete', async (result) => {
- *   const requestBody = componentResponseToV1TxCreateRequest(result.response);
- *
- *   await fetch(endpointUrl, {
- *     method: 'POST',
- *     body: JSON.stringify(requestBody)
- *   });
- * });
- * ```
- */
-export function componentResponseToV1TxCreateRequest(
-  response: TransactionResponse<Withdrawal>,
-): TransactionCreateRequest {
-  if (!response.txCreate || !response.ivms101) {
-    throw new Error(
-      'Invalid response: missing required txCreate or ivms101 data',
-    );
-  }
-
-  const { value, ivms101, proof, txCreate } = response;
-
-  // Build withdrawal object from response data for V1 API
-  const withdrawal: Withdrawal = {
-    destination: value?.destination || '',
-    counterparty: value?.counterparty || {},
-    agent: value?.agent,
-    account: value?.account,
-    proof,
-    asset:
-      value?.asset ||
-      (typeof txCreate.transactionAsset === 'string'
-        ? txCreate.transactionAsset
-        : txCreate.transactionAsset?.caip19) ||
-      '',
-    amountDecimal: value?.amountDecimal ?? txCreate.transactionAmount ?? 0,
-    customer: value?.customer,
-  } as Withdrawal;
-
-  return mapToV1CreateRequest(withdrawal, txCreate, ivms101 as any);
-}
-
 /**
  * Transforms a Notabene component response into txCreate, IVMS101, and confirmRelationship request bodies
  *

package/src/responseTransformer/types.ts

@@ -32,24 +32,6 @@ export interface ResponseToIVMS101RequestConfig extends BaseRequestConfig {
 export type ResponseToTxRequestConfig = ResponseToTxCreateRequestConfig &
   ResponseToIVMS101RequestConfig;
 
-export interface TransactionCreateRequest {
-  transactionAsset: any;
-  transactionAmount: string;
-  beneficiaryDid?: string;
-  originatorVASPdid: string;
-  beneficiaryVASPdid?: string;
-  beneficiaryVASPname?: string;
-  beneficiaryVASPwebsite?: string;
-  transactionBlockchainInfo: {
-    origin?: string;
-    destination?: string;
-  };
-  beneficiaryProof?: any;
-  beneficiary?: any;
-  originator?: any;
-  originatorEqualsBeneficiary?: boolean;
-}
-
 export interface TransactionCreateRequestV2 {
   originator: {
     '@id': string;

package/src/utils/MessageEventManager.ts

@@ -38,6 +38,8 @@ export class MessageEventManager<T, O> {
    */
 
   setPort(port: MessagePort): void {
+    if (!port) return;
+    this.port?.close();
     this.port = port;
     this.port.onmessage = this.handleMessage;
     this.port.start();

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

@@ -24,6 +24,14 @@ describe('MessageEventManager', () => {
   });
 
   describe('setPort', () => {
+    it('should ignore undefined port', () => {
+      expect(() =>
+        messageEventManager.setPort(undefined as unknown as MessagePort),
+      ).not.toThrow();
+    });
+  });
+
+  describe('setPort with valid port', () => {
     beforeEach(() => {
       messageEventManager.setPort(mockPort);
     });