feat: refactor lit protocol provider

package.json

@@ -28,12 +28,14 @@
     "publish-manual-prerelease": "lerna publish prerelease --conventional-commits --conventional-prerelease --exact --no-git-tag-version --no-push --preid next --no-verify-access --dist-tag next",
     "publish-prerelease": "FORCE_PUBLISH=$(lerna changed --json | jq '. | map(.name) | join (\",\")' -r) && echo $FORCE_PUBLISH && lerna publish --conventional-commits --conventional-prerelease --exact --no-git-tag-version --no-push --preid next --no-verify-access --dist-tag next --yes --force-publish=${FORCE_PUBLISH}",
     "deploy:contracts": "yarn workspace @requestnetwork/smart-contracts deploy",
-    "start:request-node": "yarn workspace @requestnetwork/request-node start",
+    "start:request-node": "LIT_PROTOCOL_NETWORK=datil-dev yarn workspace @requestnetwork/request-node start",
     "test": "lerna run test",
     "format": "prettier . -w",
     "format:check": "prettier . -c",
-    "link:all": "for d in packages/*; do cd $d; yarn link; cd -; done",
-    "unlink:all": "for d in packages/*; do cd $d; yarn unlink; cd -; done"
+    "link:all-npm": "for d in packages/*; do cd $d; npm link; cd -; done",
+    "unlink:all-npm": "for d in packages/*; do cd $d; npm unlink; cd -; done",
+    "link:all-yarn": "for d in packages/*; do cd $d; yarn link; cd -; done",
+    "unlink:all-yarn": "for d in packages/*; do cd $d; yarn unlink; cd -; done"
   },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "4.18.0",

packages/ethereum-storage/test/ipfs-manager.test.ts

@@ -3,6 +3,7 @@ import IpfsManager from '../src/ipfs-manager';
 import { setupServer } from 'msw/node';
 import { HttpResponse, delay, http } from 'msw';
 
+jest.setTimeout(30000);
 const testErrorHandling: StorageTypes.IIpfsErrorHandlingConfiguration = {
   delayBetweenRetries: 0,
   maxRetries: 0,

packages/integration-test/jest.config.js

@@ -1,3 +1,8 @@
+// The error ReferenceError: crypto is not defined occurs because the Node.js environment needs the crypto module to be explicitly available.
+// For Node.js versions before 19, you need to add the crypto global explicitly.
+const { webcrypto } = require('crypto');
+global.crypto = webcrypto;
+
 const jestCommonConfig = require('../../jest.config');
 
 /** @type {import('jest').Config} */

packages/integration-test/package.json

@@ -29,17 +29,19 @@
     "build": "tsc -b tsconfig.build.json",
     "clean": "rm -rf dist tsconfig.tsbuildinfo tsconfig.build.tsbuildinfo",
     "lint": "eslint \"test/**/*.ts\"",
-    "test": "run-s test:node test:layers",
+    "test": "run-s test:lit test:node test:layers",
     "test:scheduled": "run-s test:erc20 test:any test:erc777 test:eth test:btc ",
     "test:layers": "jest test/layers.test.ts  --forceExit",
     "test:node": "jest test/node-client.test.ts --forceExit",
     "test:any": "jest test/scheduled/any*.test.ts --forceExit",
     "test:eth": "jest test/scheduled/eth*.test.ts --forceExit",
     "test:erc20": "jest test/scheduled/erc20*.test.ts --forceExit",
     "test:erc777": "jest test/scheduled/erc777*.test.ts --forceExit",
-    "test:btc": "jest test/scheduled/btc.test.ts --forceExit"
+    "test:btc": "jest test/scheduled/btc.test.ts --forceExit",
+    "test:lit": "jest test/lit-protocol.test.ts --forceExit"
   },
   "devDependencies": {
+    "@lit-protocol/lit-node-client": "7.0.2",
     "@requestnetwork/advanced-logic": "0.47.0",
     "@requestnetwork/currency": "0.21.0",
     "@requestnetwork/data-access": "0.38.0",

packages/integration-test/test/lit-protocol.test.ts

@@ -0,0 +1,220 @@
+import { EthereumPrivateKeySignatureProvider } from '@requestnetwork/epk-signature';
+import { LitProtocolCipherProvider } from '@requestnetwork/lit-protocol-cipher';
+import { RequestNetwork, Types, Utils } from '@requestnetwork/request-client.js';
+import { ethers } from 'ethers';
+import { LitNodeClient } from '@lit-protocol/lit-node-client';
+
+jest.setTimeout(30000);
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitForConfirmation(request: any, maxAttempts = 10, delayMs = 1000): Promise<void> {
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    try {
+      const data = await request.getData();
+      if (data.state === Types.RequestLogic.STATE.CREATED) {
+        console.log(`Request confirmed with state: ${data.state}`);
+        return;
+      }
+      console.log(
+        `Attempt ${attempts + 1}: Request not confirmed yet. Current state: ${data.state}`,
+      );
+    } catch (error) {
+      console.log(`Attempt ${attempts + 1} failed:`, error);
+    }
+    await sleep(delayMs);
+    attempts++;
+  }
+  throw new Error(`Request not confirmed after ${maxAttempts} attempts`);
+}
+
+describe('Lit Protocol Integration Tests', () => {
+  let requestNetwork: RequestNetwork;
+  let litProvider: LitProtocolCipherProvider;
+  let epkSignatureProvider: EthereumPrivateKeySignatureProvider;
+  let userWallet: ethers.Wallet;
+  let litClient: LitNodeClient;
+
+  const nodeConnectionConfig = {
+    baseURL: 'http://localhost:3000',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  };
+
+  beforeAll(async () => {
+    // Create wallet
+    userWallet = new ethers.Wallet(
+      '0x7b595b2bb732edddc4d4fe758ae528c7a748c40f0f6220f4494e214f15c5bfeb',
+    );
+
+    // Initialize signature provider
+    epkSignatureProvider = new EthereumPrivateKeySignatureProvider({
+      method: Types.Signature.METHOD.ECDSA,
+      privateKey: userWallet.privateKey,
+    });
+
+    // Initialize Lit Protocol client
+    litClient = new LitNodeClient({
+      litNetwork: 'datil-dev',
+      alertWhenUnauthorized: false,
+      debug: false,
+    });
+
+    // Initialize Lit Protocol provider
+    litProvider = new LitProtocolCipherProvider(litClient, nodeConnectionConfig);
+    await litProvider.initializeClient();
+    await litProvider.enableDecryption(true);
+    await litProvider.getSessionSignatures(userWallet, userWallet.address);
+
+    // Initialize Request Network client
+    requestNetwork = new RequestNetwork({
+      nodeConnectionConfig,
+      signatureProvider: epkSignatureProvider,
+      cipherProvider: litProvider,
+    });
+  }, 30000);
+
+  afterAll(async () => {
+    try {
+      // Get all pending promises
+      const promises = [];
+      if (litProvider) {
+        promises.push(litProvider.disconnectClient());
+        promises.push(litProvider.disconnectWallet());
+      }
+      if (litClient) {
+        promises.push(litClient.disconnect());
+      }
+
+      // Wait for all cleanup operations to complete
+      await Promise.all(promises);
+    } catch (error) {
+      console.error('Cleanup error:', error);
+    }
+  });
+
+  it('should encrypt and decrypt data directly', async () => {
+    const testData = 'test encryption';
+    const encryptionParams = [
+      {
+        key: userWallet.address,
+        method: Types.Encryption.METHOD.KMS,
+      },
+    ];
+
+    const encrypted = await litProvider.encrypt(testData, { encryptionParams });
+    expect(encrypted).toBeDefined();
+    expect(encrypted?.ciphertext).toBeDefined();
+    expect(encrypted?.dataToEncryptHash).toBeDefined();
+
+    const decrypted = await litProvider.decrypt(encrypted!, { encryptionParams });
+    expect(decrypted).toBe(testData);
+  });
+
+  it('should create and encrypt a request', async () => {
+    const requestParams = {
+      requestInfo: {
+        currency: {
+          type: Types.RequestLogic.CURRENCY.ETH,
+          value: '0x0000000000000000000000000000000000000000',
+          network: 'sepolia',
+        },
+        expectedAmount: ethers.utils.parseEther('0.1').toString(),
+        payee: {
+          type: Types.Identity.TYPE.ETHEREUM_ADDRESS,
+          value: userWallet.address,
+        },
+        payer: {
+          type: Types.Identity.TYPE.ETHEREUM_ADDRESS,
+          value: '0xb07D2398d2004378cad234DA0EF14f1c94A530e4',
+        },
+        timestamp: Utils.getCurrentTimestampInSecond(),
+      },
+      paymentNetwork: {
+        id: Types.Extension.PAYMENT_NETWORK_ID.ETH_FEE_PROXY_CONTRACT,
+        parameters: {
+          paymentNetworkName: 'sepolia',
+          paymentAddress: userWallet.address,
+          feeAddress: '0x0000000000000000000000000000000000000000',
+          feeAmount: '0',
+          tokenAddress: '0x0000000000000000000000000000000000000000',
+        },
+      },
+      contentData: {
+        meta: {
+          format: 'rnf_invoice',
+          version: '0.0.3',
+        },
+        creationDate: new Date().toISOString(),
+        invoiceNumber: 'INV-2023-001',
+        invoiceItems: [
+          {
+            name: 'Test Service',
+            quantity: 1,
+            unitPrice: ethers.utils.parseEther('0.1').toString(),
+            discount: '0',
+            tax: {
+              type: 'percentage',
+              amount: '0',
+            },
+            currency: 'ETH',
+          },
+        ],
+      },
+      signer: {
+        type: Types.Identity.TYPE.ETHEREUM_ADDRESS,
+        value: userWallet.address,
+      },
+    };
+
+    const encryptionParams = [
+      {
+        key: userWallet.address,
+        method: Types.Encryption.METHOD.KMS,
+      },
+    ];
+
+    const encryptedRequest = await requestNetwork._createEncryptedRequest(
+      requestParams as Types.ICreateRequestParameters,
+      encryptionParams,
+    );
+
+    await waitForConfirmation(encryptedRequest, 15, 2000);
+
+    const requestData = await encryptedRequest.getData();
+    expect(requestData).toBeDefined();
+    expect([Types.RequestLogic.STATE.CREATED]).toContain(requestData.state);
+  });
+
+  it('should handle encryption errors gracefully', async () => {
+    const invalidEncryptionParams = [
+      {
+        key: '',
+        method: Types.Encryption.METHOD.KMS,
+      },
+    ];
+
+    await expect(
+      litProvider.encrypt('test data', { encryptionParams: invalidEncryptionParams }),
+    ).rejects.toThrow(/invalid.*key/i);
+  });
+
+  it('should handle decryption errors gracefully', async () => {
+    const invalidEncryptedData = {
+      ciphertext: 'invalid-ciphertext',
+      dataToEncryptHash: 'invalid-hash',
+    };
+
+    await expect(
+      litProvider.decrypt(invalidEncryptedData, {
+        encryptionParams: [
+          {
+            key: userWallet.address,
+            method: Types.Encryption.METHOD.KMS,
+          },
+        ],
+      }),
+    ).rejects.toThrow();
+  });
+});

packages/integration-test/tsconfig.build.json

@@ -12,6 +12,7 @@
     { "path": "../ethereum-storage/tsconfig.build.json" },
     { "path": "../epk-decryption/tsconfig.build.json" },
     { "path": "../epk-signature/tsconfig.build.json" },
+    { "path": "../lit-protocol-cipher/tsconfig.build.json" },
     { "path": "../multi-format/tsconfig.build.json" },
     { "path": "../payment-processor/tsconfig.build.json" },
     { "path": "../request-logic/tsconfig.build.json" },

packages/lit-protocol-cipher/README.md

@@ -1,8 +1,8 @@
 # @requestnetwork/lit-protocol-cipher
 
-Lit Protocol Provider.
+Lit Protocol Provider for Request Network.
 
-`@requestnetwork/lit-protocol-cipher` is a typescript library part of the [Request Network protocol](https://github.com/RequestNetwork/requestNetwork).
+`@requestnetwork/lit-protocol-cipher` is a typescript library part of the [Request Network protocol](https://github.com/RequestNetwork/requestNetwork) that provides encryption and decryption capabilities using the Lit Protocol.
 
 ## Installation
 
@@ -12,22 +12,33 @@ npm install @requestnetwork/lit-protocol-cipher
 
 ## Usage
 
-The `LitProvider` class provides encryption and decryption capabilities using the Lit Protocol. Here's how to implement and use it:
+The `LitProtocolCipherProvider` class provides encryption and decryption capabilities using the Lit Protocol. Here's how to implement and use it:
 
 ```typescript
 import { ethers } from 'ethers';
-import LitProvider from './LitProvider';
+import { LitProtocolCipherProvider } from '@requestnetwork/lit-protocol-cipher';
 import { LIT_NETWORKS } from '@lit-protocol/types';
+import { LitNodeClient } from '@lit-protocol/lit-node-client';
 
 // Initialize the provider
-const litProvider = new LitProvider(
-  'ethereum', // chain
-  LIT_NETWORKS.MAINNET, // network
+const litProvider = new LitProtocolCipherProvider(
+  new LitNodeClient({
+    litNetwork: LIT_NETWORKS.datil,
+  }),
   {
-    nodeUrl: 'https://your-request-network-node.com',
+    baseURL: 'https://gnosis.gateway.request.network',
+    headers: {
+      'Content-Type': 'application/json',
+    },
   }, // nodeConnectionConfig
 );
 
+// Initialize the client
+await litProvider.initializeClient();
+
+// Enable decryption
+await litProvider.enableDecryption(true);
+
 // Example usage with wallet connection
 async function example() {
   try {
@@ -70,11 +81,11 @@ async function example() {
       const parsedData = JSON.parse(decryptedData);
       console.log('Decrypted data:', parsedData);
     }
-
-    // Disconnect wallet when done
-    await litProvider.disconnectWallet();
   } catch (error) {
     console.error('Error:', error);
+  } finally {
+    // Disconnect wallet when done
+    await litProvider.disconnectWallet();
   }
 }
 

packages/lit-protocol-cipher/package.json

@@ -40,13 +40,13 @@
     "test:watch": "yarn test --watch"
   },
   "dependencies": {
-    "@lit-protocol/auth-helpers": "7.0.0",
-    "@lit-protocol/constants": "7.0.0",
+    "@lit-protocol/auth-helpers": "7.0.2",
+    "@lit-protocol/constants": "7.0.2",
     "@lit-protocol/contracts": "0.0.74",
-    "@lit-protocol/encryption": "7.0.0",
-    "@lit-protocol/lit-node-client": "7.0.0",
-    "@lit-protocol/lit-node-client-nodejs": "7.0.0",
-    "@lit-protocol/types": "7.0.0",
+    "@lit-protocol/encryption": "7.0.2",
+    "@lit-protocol/lit-node-client": "7.0.2",
+    "@lit-protocol/lit-node-client-nodejs": "7.0.2",
+    "@lit-protocol/types": "7.0.2",
     "@requestnetwork/request-client.js": "0.52.0",
     "@requestnetwork/types": "0.47.0",
     "@walletconnect/modal": "2.7.0",

packages/lit-protocol-cipher/src/index.ts

@@ -1 +1 @@
-export { default as LitProtocolProvider } from './lit-protocol-cipher-provider';
+export { default as LitProtocolCipherProvider } from './lit-protocol-cipher-provider';