Feature/3404 datil dev support

local-tests/README.md

@@ -37,20 +37,21 @@ Below is the API documentation for the `ProcessEnvs` interface, detailing the co
 
 **NOTE: a `.env.sample` is contained in the repository root for the below env tables**
 
-| Variable                 | Description                                                                                                                                                              |
-| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `MAX_ATTEMPTS`           | Each test is executed in a loop with a maximum number of attempts specified by `devEnv.processEnvs.MAX_ATTEMPTS`.                                                        |
-| `NETWORK`                | The network to use for testing, which can be one of the following: `LIT_TESTNET.LOCALCHAIN`, `LIT_TESTNET.MANZANO`, or `LIT_TESTNET.CAYENNE`.                            |
-| `DEBUG`                  | Specifies whether to enable debug mode.                                                                                                                                  |
-| `REQUEST_PER_KILOSECOND` | To execute a transaction with Lit, you must reserve capacity on the network using Capacity Credits. These allow a set number of requests over a period (default 2 days). |
-| `WAIT_FOR_KEY_INTERVAL`  | Wait time in milliseconds if no private keys are available.                                                                                                              |
-| `TIME_TO_RELEASE_KEY`    | Time to wait before releasing the key after requesting it.                                                                                                               |
-| `RUN_IN_BAND`            | Run all tests in a single thread.                                                                                                                                        |
-| `RUN_IN_BAND_INTERVAL`   | The interval in milliseconds to run the tests in a single thread.                                                                                                        |
-| `LIT_RPC_URL`            | The URL of the Lit RPC server. If running locally on Anvil, it should be 'http://127.0.0.1:8545'.                                                                        |
-| `LIT_OFFICIAL_RPC`       | The URL of the official Lit RPC server, usually 'https://chain-rpc.litprotocol.com/http' but can be changed if needed.                                                   |
-| `USE_SHIVA`              | A flag to determine if `Shiva` should be used for the `localchain` network.                                                                                              |
-| `PRIVATE_KEYS`           | A set of private keys to use which will be used to perform chain operations.                                                                                             |
+| Variable                 | Description                                                                                                                                                                                               |
+| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `MAX_ATTEMPTS`           | Each test is executed in a loop with a maximum number of attempts specified by `devEnv.processEnvs.MAX_ATTEMPTS`.                                                                                         |
+| `NETWORK`                | The network to use for testing, which can be one of the following: `LIT_TESTNET.LOCALCHAIN`, `LIT_TESTNET.MANZANO`, or `LIT_TESTNET.CAYENNE`.                                                             |
+| `DEBUG`                  | Specifies whether to enable debug mode.                                                                                                                                                                   |
+| `REQUEST_PER_KILOSECOND` | To execute a transaction with Lit, you must reserve capacity on the network using Capacity Credits. These allow a set number of requests over a period (default 2 days).                                  |
+| `WAIT_FOR_KEY_INTERVAL`  | Wait time in milliseconds if no private keys are available.                                                                                                                                               |
+| `TIME_TO_RELEASE_KEY`    | Time to wait before releasing the key after requesting it.                                                                                                                                                |
+| `RUN_IN_BAND`            | Run all tests in a single thread.                                                                                                                                                                         |
+| `RUN_IN_BAND_INTERVAL`   | The interval in milliseconds to run the tests in a single thread.                                                                                                                                         |
+| `LIT_RPC_URL`            | The URL of the Lit RPC server: <br> - For local Anvil: `http://127.0.0.1:8545` <br> - For Chronical: `https://chain-rpc.litprotocol.com/http` <br> - For Vesuvius: `https://vesuvius-rpc.litprotocol.com` |
+| `STOP_TESTNET`           | Flag to stop a single running testnet after the test run concludes.                                                                                                                                       |
+| `USE_SHIVA`              | A flag to determine if `Shiva` should be used for the `localchain` network.                                                                                                                               |
+| `PRIVATE_KEYS`           | A set of private keys to use which will be used to perform chain operations.                                                                                                                              |
+| `CHUNK_SIZE`             | Determines the number of tests run concurrently during parallel execution                                                                                                                                 |
 
 Below is te API Documentation forthe `ProccessEnvs` interface for the `shiva-client` detailing the configurable enviorment variables and their purposes:
 

local-tests/setup/tinny-config.ts

@@ -5,6 +5,13 @@ export enum LIT_TESTNET {
   LOCALCHAIN = 'localchain',
   MANZANO = 'manzano',
   CAYENNE = 'cayenne',
+  DATIL_DEV = 'datil-dev',
+}
+
+export enum LIT_RPC {
+  LOCAL_ANVIL = 'http://127.0.0.1:8545',
+  CHRONICAL = 'https://chain-rpc.litprotocol.com/http',
+  VESUVIUS = 'https://vesuvius-rpc.litprotocol.com',
 }
 
 export interface ProcessEnvs {
@@ -18,6 +25,7 @@ export interface ProcessEnvs {
    * - `LIT_TESTNET.LOCALCHAIN`
    * - `LIT_TESTNET.MANZANO`
    * - `LIT_TESTNET.CAYENNE`
+   * - `LIT_TESTNET.DATIL_DEV`
    */
   NETWORK: LIT_TESTNET;
 
@@ -53,14 +61,12 @@ export interface ProcessEnvs {
 
   // =========== In most cases you won't need to change the following values ===========
   /**
-   * The URL of Lit RPC server. If it's running locally on Anvil, it should be 'http://127.0.0.1:8545'
-   */
-  LIT_RPC_URL: string;
-
-  /**
-   * The URL of the official Lit RPC server. Usually 'https://chain-rpc.litprotocol.com/http' but can be changed if needed
+   * The URL of Lit RPC server.
+   * - If it's running locally on Anvil, it should be 'http://127.0.0.1:8545'
+   * - If it's running on Chronical, it should be 'https://chain-rpc.litprotocol.com/http'
+   * - If it's running on Vesuvius, it should be 'https://vesuvius-rpc.litprotocol.com'
    */
-  LIT_OFFICIAL_RPC: string;
+  LIT_RPC_URL: string | null;
 
   /**
    * This is usually used when you're running tests locally depending how many nodes you are running.

local-tests/setup/tinny-environment.ts

@@ -1,4 +1,9 @@
-import { LIT_TESTNET, ProcessEnvs, TinnyEnvConfig } from './tinny-config';
+import {
+  LIT_RPC,
+  LIT_TESTNET,
+  ProcessEnvs,
+  TinnyEnvConfig,
+} from './tinny-config';
 import { LitNodeClient } from '@lit-protocol/lit-node-client';
 import { LitContracts } from '@lit-protocol/contracts-sdk';
 import {
@@ -29,24 +34,20 @@ export class TinnyEnvironment {
     DEBUG: process.env['DEBUG'] === 'true',
     REQUEST_PER_KILOSECOND:
       parseInt(process.env['REQUEST_PER_KILOSECOND']) || 200,
-    LIT_RPC_URL: process.env['LIT_RPC_URL'] || 'http://127.0.0.1:8545',
+    LIT_RPC_URL: process.env['LIT_RPC_URL'],
     WAIT_FOR_KEY_INTERVAL:
       parseInt(process.env['WAIT_FOR_KEY_INTERVAL']) || 3000,
     BOOTSTRAP_URLS: process.env['BOOTSTRAP_URLS']?.split(',') || [
       'http://127.0.0.1:7470',
       'http://127.0.0.1:7471',
       'http://127.0.0.1:7472',
     ],
-    LIT_OFFICIAL_RPC:
-      process.env['LIT_OFFICIAL_RPC'] ||
-      'https://chain-rpc.litprotocol.com/http',
     TIME_TO_RELEASE_KEY: parseInt(process.env['TIME_TO_RELEASE_KEY']) || 10000,
     RUN_IN_BAND: process.env['RUN_IN_BAND'] === 'true',
     RUN_IN_BAND_INTERVAL: parseInt(process.env['RUN_IN_BAND_INTERVAL']) || 5000,
 
     // Available Accounts
     // ==================
-    // (0) "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" (10000.000000000000000000 ETH)
     // (1) "0x70997970C51812dc3A010C7d01b50e0d17dc79C8" (10000.000000000000000000 ETH)
     // (2) "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC" (10000.000000000000000000 ETH)
     // (3) "0x90F79bf6EB2c4f870365E785982E1f101E93b906" (10000.000000000000000000 ETH)
@@ -117,10 +118,30 @@ export class TinnyEnvironment {
     ).fill(false);
 
     // -- setup rpc
-    if (this.network === LIT_TESTNET.LOCALCHAIN) {
+    // Map of network names to their corresponding RPC URLs
+    const RPC_MAP = {
+      [LIT_TESTNET.LOCALCHAIN]: LIT_RPC.LOCAL_ANVIL,
+      [LIT_TESTNET.MANZANO]: LIT_RPC.CHRONICAL,
+      [LIT_TESTNET.DATIL_DEV]: LIT_RPC.VESUVIUS,
+    };
+
+    // -- setup rpc
+    // Priority:
+    // 1. Use environment variable if set
+    // 2. Use RPC_MAP if network is recognized
+    // 3. Throw error if neither condition is met
+    if (this.processEnvs.LIT_RPC_URL) {
+      // If LIT_RPC_URL is set in the environment, use it
       this.rpc = this.processEnvs.LIT_RPC_URL;
+    } else if (this.network in RPC_MAP) {
+      // If the network is recognized in RPC_MAP, use the corresponding RPC URL
+      this.rpc = RPC_MAP[this.network];
     } else {
-      this.rpc = this.processEnvs.LIT_OFFICIAL_RPC;
+      // If neither condition is met, throw an error with available options
+      const availableNetworks = Object.keys(RPC_MAP).join(', ');
+      throw new Error(
+        `No RPC URL found for network "${this.network}". Available networks are: ${availableNetworks}`
+      );
     }
 
     console.log(
@@ -213,7 +234,7 @@ export class TinnyEnvironment {
         this?.testnet?.ContractContext ?? this._contractContext;
       this.litNodeClient = new LitNodeClient({
         litNetwork: 'custom',
-        rpcUrl: this.processEnvs.LIT_RPC_URL,
+        rpcUrl: this.rpc,
         debug: this.processEnvs.DEBUG,
         checkNodeAttestation: false, // disable node attestation check for local testing
         contractContext: networkContext,
@@ -411,22 +432,34 @@ export class TinnyEnvironment {
       this.contractsClient = new LitContracts({
         signer: wallet,
         debug: this.processEnvs.DEBUG,
-        rpc: this.processEnvs.LIT_RPC_URL, // anvil rpc
+        rpc: this.rpc,
         customContext: networkContext,
-      });
+      });F
     } else {
-      // TODO: This wallet should be cached somehwere and reused to create delegation signatures.
-      // There is a correlation between the number of Capacity Credit NFTs in a wallet and the speed at which nodes can verify a given rate limit authorization. Creating a single wallet to hold all Capacity Credit NFTs improves network performance during tests.
-      const capacityCreditWallet =
-        ethers.Wallet.createRandom().connect(provider);
-
-      const transferTx = await wallet.sendTransaction({
-        to: capacityCreditWallet.address,
-        value: ethers.utils.parseEther('0.001'),
-      });
-      await transferTx.wait();
+      async function _switchWallet() {
+        // TODO: This wallet should be cached somehwere and reused to create delegation signatures.
+        // There is a correlation between the number of Capacity Credit NFTs in a wallet and the speed at which nodes can verify a given rate limit authorization. Creating a single wallet to hold all Capacity Credit NFTs improves network performance during tests.
+        const capacityCreditWallet =
+          ethers.Wallet.createRandom().connect(provider);
+
+        // get wallet balance
+        const balance = await wallet.getBalance();
+        console.log('this.rpc:', this.rpc);
+        console.log('this.wallet.address', wallet.address);
+        console.log('Balance:', balance.toString());
+
+        const transferTx = await wallet.sendTransaction({
+          to: capacityCreditWallet.address,
+          value: ethers.utils.parseEther('0.001'),
+        });
+        await transferTx.wait();
+      }
+
+      // await _switchWallet();
+
       this.contractsClient = new LitContracts({
-        signer: capacityCreditWallet,
+        // signer: capacityCreditWallet, // disabled switch wallet for now
+        signer: wallet,
         debug: this.processEnvs.DEBUG,
         network: this.network,
       });
@@ -439,23 +472,40 @@ export class TinnyEnvironment {
      * Mint a Capacity Credits NFT and get a capacity delegation authSig with it
      * ====================================
      */
-    console.log(
-      '[𐬺🧪 Tinny Environment𐬺] Mint a Capacity Credits NFT and get a capacity delegation authSig with it'
-    );
-    const capacityTokenId = (
-      await this.contractsClient.mintCapacityCreditsNFT({
-        requestsPerKilosecond: this.processEnvs.REQUEST_PER_KILOSECOND,
-        daysUntilUTCMidnightExpiration: 2,
-      })
-    ).capacityTokenIdStr;
-
-    this.superCapacityDelegationAuthSig = (
-      await this.litNodeClient.createCapacityDelegationAuthSig({
-        dAppOwnerWallet: wallet,
-        capacityTokenId: capacityTokenId,
-        // Sets a maximum limit of 200 times that the delegation can be used and prevents usage beyond it
-        uses: '200',
-      })
-    ).capacityDelegationAuthSig;
+
+    // Disabled for now
+    async function _mintSuperCapacityDelegationAuthSig() {
+      console.log(
+        '[𐬺🧪 Tinny Environment𐬺] Mint a Capacity Credits NFT and get a capacity delegation authSig with it'
+      );
+      try {
+        const capacityTokenId = (
+          await this.contractsClient.mintCapacityCreditsNFT({
+            requestsPerKilosecond: this.processEnvs.REQUEST_PER_KILOSECOND,
+            daysUntilUTCMidnightExpiration: 2,
+          })
+        ).capacityTokenIdStr;
+
+        this.superCapacityDelegationAuthSig = (
+          await this.litNodeClient.createCapacityDelegationAuthSig({
+            dAppOwnerWallet: wallet,
+            capacityTokenId: capacityTokenId,
+            // Sets a maximum limit of 200 times that the delegation can be used and prevents usage beyond it
+            uses: '200',
+          })
+        ).capacityDelegationAuthSig;
+      } catch (e: any) {
+        if (
+          e.message.includes(`Can't allocate capacity beyond the global max`)
+        ) {
+          console.log('❗️Skipping capacity delegation auth sig setup.', e);
+        } else {
+          console.log(
+            '❗️Error while setting up capacity delegation auth sig',
+            e
+          );
+        }
+      }
+    }
   };
 }