feat: Create new data access to allow for in-memory transactions.

packages/request-client.js/src/api/request-network.ts

@@ -4,10 +4,12 @@ import { RequestLogic } from '@requestnetwork/request-logic';
 import { TransactionManager } from '@requestnetwork/transaction-manager';
 import {
   AdvancedLogicTypes,
+  ClientTypes,
   CurrencyTypes,
   DataAccessTypes,
   DecryptionProviderTypes,
   EncryptionTypes,
+  ExtensionTypes,
   IdentityTypes,
   PaymentTypes,
   RequestLogicTypes,
@@ -20,6 +22,7 @@ import * as Types from '../types';
 import ContentDataExtension from './content-data-extension';
 import Request from './request';
 import localUtils from './utils';
+import { NoPersistHttpDataAccess } from '../no-persist-http-data-access';
 
 /**
  * Entry point of the request-client.js library. Create requests, get requests, manipulate requests.
@@ -31,6 +34,7 @@ export default class RequestNetwork {
   private requestLogic: RequestLogicTypes.IRequestLogic;
   private transaction: TransactionTypes.ITransactionManager;
   private advancedLogic: AdvancedLogicTypes.IAdvancedLogic;
+  private dataAccess: DataAccessTypes.IDataAccess;
 
   private contentData: ContentDataExtension;
   private currencyManager: CurrencyTypes.ICurrencyManager;
@@ -55,6 +59,7 @@ export default class RequestNetwork {
     paymentOptions?: Partial<PaymentNetworkOptions>;
   }) {
     this.currencyManager = currencyManager || CurrencyManager.getDefault();
+    this.dataAccess = dataAccess;
     this.advancedLogic = new AdvancedLogic(this.currencyManager);
     this.transaction = new TransactionManager(dataAccess, decryptionProvider);
     this.requestLogic = new RequestLogic(this.transaction, signatureProvider, this.advancedLogic);
@@ -85,28 +90,66 @@ export default class RequestNetwork {
       topics,
     );
 
+    const transactionData = requestLogicCreateResult.meta?.transactionManagerMeta.transactionData;
+    const requestId = requestLogicCreateResult.result.requestId;
+    const isSkippingPersistence = this.dataAccess instanceof NoPersistHttpDataAccess;
     // create the request object
-    const request = new Request(
-      requestLogicCreateResult.result.requestId,
-      this.requestLogic,
-      this.currencyManager,
-      {
-        contentDataExtension: this.contentData,
-        paymentNetwork,
-        requestLogicCreateResult,
-        skipPaymentDetection: parameters.disablePaymentDetection,
-        disableEvents: parameters.disableEvents,
-      },
-    );
+    const request = new Request(requestId, this.requestLogic, this.currencyManager, {
+      contentDataExtension: this.contentData,
+      paymentNetwork,
+      requestLogicCreateResult,
+      skipPaymentDetection: parameters.disablePaymentDetection,
+      disableEvents: parameters.disableEvents,
+      // inMemoryInfo is only used when skipPersistence is enabled
+      inMemoryInfo: isSkippingPersistence
+        ? {
+            topics: requestLogicCreateResult.meta.transactionManagerMeta?.topics,
+            transactionData: transactionData,
+            requestData: this.prepareRequestDataForPayment(transactionData, requestId),
+          }
+        : null,
+    });
 
-    if (!options?.skipRefresh) {
+    if (!options?.skipRefresh && !isSkippingPersistence) {
       // refresh the local request data
       await request.refresh();
     }
 
     return request;
   }
 
+  /**
+   * Persists an in-memory request to the data-access layer.
+   *
+   * This method is used to persist requests that were initially created with skipPersistence enabled.
+   *
+   * @param request The Request object to persist. This must be a request that was created with skipPersistence enabled.
+   * @returns A promise that resolves to the result of the persist transaction operation.
+   * @throws {Error} If the request's `inMemoryInfo` is not provided, indicating it wasn't created with skipPersistence.
+   * @throws {Error} If the current data access instance does not support persistence (e.g., NoPersistHttpDataAccess).
+   */
+  public async persistRequest(
+    request: Request,
+  ): Promise<DataAccessTypes.IReturnPersistTransaction> {
+    if (!request.inMemoryInfo) {
+      throw new Error('Cannot persist request without inMemoryInfo.');
+    }
+
+    if (this.dataAccess instanceof NoPersistHttpDataAccess) {
+      throw new Error(
+        'Cannot persist request when skipPersistence is enabled. To persist the request, create a new instance of RequestNetwork without skipPersistence being set to true.',
+      );
+    }
+    const result: DataAccessTypes.IReturnPersistTransaction =
+      await this.dataAccess.persistTransaction(
+        request.inMemoryInfo.transactionData,
+        request.requestId,
+        request.inMemoryInfo.topics,
+      );
+
+    return result;
+  }
+
   /**
    * Creates an encrypted request.
    *
@@ -129,21 +172,27 @@ export default class RequestNetwork {
       topics,
     );
 
+    const transactionData = requestLogicCreateResult.meta?.transactionManagerMeta.transactionData;
+    const requestId = requestLogicCreateResult.result.requestId;
+    const isSkippingPersistence = this.dataAccess instanceof NoPersistHttpDataAccess;
+
     // create the request object
-    const request = new Request(
-      requestLogicCreateResult.result.requestId,
-      this.requestLogic,
-      this.currencyManager,
-      {
-        contentDataExtension: this.contentData,
-        paymentNetwork,
-        requestLogicCreateResult,
-        skipPaymentDetection: parameters.disablePaymentDetection,
-        disableEvents: parameters.disableEvents,
-      },
-    );
+    const request = new Request(requestId, this.requestLogic, this.currencyManager, {
+      contentDataExtension: this.contentData,
+      paymentNetwork,
+      requestLogicCreateResult,
+      skipPaymentDetection: parameters.disablePaymentDetection,
+      disableEvents: parameters.disableEvents,
+      inMemoryInfo: isSkippingPersistence
+        ? {
+            topics: requestLogicCreateResult.meta.transactionManagerMeta?.topics,
+            transactionData: transactionData,
+            requestData: this.prepareRequestDataForPayment(transactionData, requestId),
+          }
+        : null,
+    });
 
-    if (!options?.skipRefresh) {
+    if (!options?.skipRefresh && !isSkippingPersistence) {
       // refresh the local request data
       await request.refresh();
     }
@@ -437,4 +486,77 @@ export default class RequestNetwork {
 
     return { requestParameters: copiedRequestParameters, topics, paymentNetwork };
   }
+
+  /**
+   * Prepares a payment request structure from transaction data.
+   *
+   * This method is used to create a request structure similar to a persisted request,
+   * allowing users to pay before the request is persisted. This is useful in scenarios
+   * where a request is created, paid, and then persisted, as opposed to the normal flow
+   * of creating, persisting, and then paying the request.
+   *
+   * @param transactionData The transaction data containing the request information
+   * @param requestId The ID of the request
+   * @returns The prepared payment request structure or undefined if transaction data is missing
+   */
+  private prepareRequestDataForPayment(
+    transactionData: DataAccessTypes.ITransaction,
+    requestId: string,
+  ): ClientTypes.IRequestData {
+    const requestData = JSON.parse(transactionData.data as string).data;
+    const originalExtensionsData = requestData.parameters.extensionsData;
+    const newExtensions: RequestLogicTypes.IExtensionStates = {};
+
+    for (const extension of originalExtensionsData) {
+      if (extension.id !== ExtensionTypes.OTHER_ID.CONTENT_DATA) {
+        newExtensions[extension.id] = {
+          events: [
+            {
+              name: extension.action,
+              parameters: {
+                paymentAddress: extension.parameters.paymentAddress,
+                salt: extension.parameters.salt,
+              },
+              timestamp: requestData.parameters.timestamp,
+            },
+          ],
+          id: extension.id,
+          type: ExtensionTypes.TYPE.PAYMENT_NETWORK,
+          values: {
+            salt: extension.parameters.salt,
+            receivedPaymentAmount: '0',
+            receivedRefundAmount: '0',
+            sentPaymentAmount: '0',
+            sentRefundAmount: '0',
+            paymentAddress: extension.parameters.paymentAddress,
+          },
+          version: extension.version,
+        };
+      }
+    }
+
+    return {
+      requestId: requestId,
+      currency: requestData.parameters.currency.type,
+      meta: null,
+      balance: null,
+      expectedAmount: requestData.parameters.expectedAmount,
+      contentData: requestData.parameters.extensionsData.find(
+        (ext: ExtensionTypes.IAction) => ext.id === ExtensionTypes.OTHER_ID.CONTENT_DATA,
+      )?.parameters.content,
+      currencyInfo: {
+        type: requestData.parameters.currency.type,
+        network: requestData.parameters.currency.network,
+        value: requestData.parameters.currency.value || '',
+      },
+      pending: null,
+      extensions: newExtensions,
+      extensionsData: requestData.parameters.extensionsData,
+      timestamp: requestData.parameters.timestamp,
+      version: requestData.parameters.version,
+      creator: requestData.parameters.creator,
+      state: requestData.parameters.state,
+      events: requestData.parameters.events,
+    };
+  }
 }

packages/request-client.js/src/api/request.ts

@@ -78,6 +78,17 @@ export default class Request {
    */
   private currencyManager: CurrencyTypes.ICurrencyManager;
 
+  /**
+   * Information for an in-memory request, including transaction data, topics, and payment request data.
+   * This is used for requests that haven't been persisted yet, allowing for operations like payments
+   * before the request is stored in the data access layer.
+   *
+   * @property transactionData - Transaction data necessary for persisting the request later on.
+   * @property topics - Topics of the request, used for indexing and retrieval when persisting.
+   * @property requestData - Structured data primarily used for processing payments before the request is persisted.
+   */
+  public readonly inMemoryInfo: RequestLogicTypes.IInMemoryInfo | null = null;
+
   /**
    * Creates an instance of Request
    *
@@ -98,6 +109,7 @@ export default class Request {
       requestLogicCreateResult?: RequestLogicTypes.IReturnCreateRequest;
       skipPaymentDetection?: boolean;
       disableEvents?: boolean;
+      inMemoryInfo?: RequestLogicTypes.IInMemoryInfo | null;
     },
   ) {
     this.requestLogic = requestLogic;
@@ -108,6 +120,7 @@ export default class Request {
     this.skipPaymentDetection = options?.skipPaymentDetection || false;
     this.disableEvents = options?.disableEvents || false;
     this.currencyManager = currencyManager;
+    this.inMemoryInfo = options?.inMemoryInfo || null;
 
     if (options?.requestLogicCreateResult && !this.disableEvents) {
       const originalEmitter = options.requestLogicCreateResult;

packages/request-client.js/src/http-request-network.ts

@@ -11,6 +11,7 @@ import RequestNetwork from './api/request-network';
 import HttpDataAccess, { NodeConnectionConfig } from './http-data-access';
 import { MockDataAccess } from '@requestnetwork/data-access';
 import { MockStorage } from './mock-storage';
+import { NoPersistHttpDataAccess } from './no-persist-http-data-access';
 
 /**
  * Exposes RequestNetwork module configured to use http-data-access.
@@ -21,10 +22,11 @@ export default class HttpRequestNetwork extends RequestNetwork {
    *
    * @param options.httpConfig Http config that will be used by the underlying data-access. @see ClientTypes.IHttpDataAccessConfig for available options.
    * @param options.nodeConnectionConfig Configuration options to connect to the node.
-   * @param options.useMockStorage When true, will use a mock storage in memory. Meant to simplify local development and should never be used in production.
+   * @param options.useMockStorage When true, will use a mock storage in memory. Meant to simplify local development and should never be used in production. Overrides `skipPersistence` when both are true.
    * @param options.signatureProvider Module to handle the signature. If not given it will be impossible to create new transaction (it requires to sign).
-   * @param options.currencies custom currency list
-   * @param options.currencyManager custom currency manager (will override `currencies`)
+   * @param options.currencies custom currency list.
+   * @param options.currencyManager custom currency manager (will override `currencies`).
+   * @param options.skipPersistence allows creating a transaction without immediate persistence.
    */
   constructor(
     {
@@ -35,6 +37,7 @@ export default class HttpRequestNetwork extends RequestNetwork {
       useMockStorage,
       currencyManager,
       paymentOptions,
+      skipPersistence,
     }: {
       decryptionProvider?: DecryptionProviderTypes.IDecryptionProvider;
       httpConfig?: Partial<ClientTypes.IHttpDataAccessConfig>;
@@ -43,13 +46,20 @@ export default class HttpRequestNetwork extends RequestNetwork {
       useMockStorage?: boolean;
       currencyManager?: CurrencyTypes.ICurrencyManager;
       paymentOptions?: Partial<PaymentNetworkOptions>;
+      skipPersistence?: boolean;
     } = {
       httpConfig: {},
       useMockStorage: false,
+      skipPersistence: false,
     },
   ) {
     const dataAccess: DataAccessTypes.IDataAccess = useMockStorage
       ? new MockDataAccess(new MockStorage())
+      : skipPersistence
+      ? new NoPersistHttpDataAccess({
+          httpConfig,
+          nodeConnectionConfig,
+        })
       : new HttpDataAccess({ httpConfig, nodeConnectionConfig });
 
     if (!currencyManager) {

packages/request-client.js/src/no-persist-http-data-access.ts

@@ -0,0 +1,48 @@
+import HttpDataAccess, { NodeConnectionConfig } from './http-data-access';
+import { ClientTypes, DataAccessTypes, StorageTypes } from '@requestnetwork/types';
+import { EventEmitter } from 'events';
+
+export class NoPersistHttpDataAccess extends HttpDataAccess {
+  constructor(
+    {
+      httpConfig,
+      nodeConnectionConfig,
+    }: {
+      httpConfig?: Partial<ClientTypes.IHttpDataAccessConfig>;
+      nodeConnectionConfig?: Partial<NodeConnectionConfig>;
+    } = {
+      httpConfig: {},
+      nodeConnectionConfig: {},
+    },
+  ) {
+    super({ httpConfig, nodeConnectionConfig });
+  }
+
+  async persistTransaction(
+    transactionData: DataAccessTypes.ITransaction,
+    channelId: string,
+    topics?: string[],
+  ): Promise<DataAccessTypes.IReturnPersistTransaction> {
+    const data: DataAccessTypes.IReturnPersistTransactionRaw = {
+      meta: {
+        topics: topics || [],
+        transactionStorageLocation: '',
+        storageMeta: {
+          state: StorageTypes.ContentState.PENDING,
+          timestamp: Date.now() / 1000,
+        },
+      },
+      result: {},
+    };
+
+    const result: DataAccessTypes.IReturnPersistTransaction = Object.assign(
+      new EventEmitter() as DataAccessTypes.PersistTransactionEmitter,
+      data,
+    );
+
+    // Emit confirmation instantly since data is not going to be persisted
+    result.emit('confirmed', result);
+
+    return result;
+  }
+}

packages/request-client.js/test/http-request-network.test.ts

@@ -18,7 +18,7 @@ afterAll(() => {
 });
 
 afterEach(() => {
-  mockServer.restoreHandlers();
+  mockServer.resetHandlers();
 });
 
 describe('HttpRequestNetwork', () => {