feat: cayenne remappings

packages/constants/src/lib/constants/constants.ts

@@ -729,6 +729,11 @@ export const SYMM_KEY_ALGO_PARAMS = {
   length: 256,
 };
 
+/**
+ * Default node URL for Cayenne network
+ */
+export const CAYENNE_URL = 'https://cayenne.litgateway.com';
+
 /**
  * Default node URLs for each LIT network
  * Note: Dynamic networks such as Habanero have no default node URLS; they are always
@@ -739,9 +744,9 @@ export const LIT_NETWORKS: { [key in LitNetwork]: string[] } & {
   internalDev: string[];
 } = {
   [LitNetwork.Cayenne]: [
-    'https://cayenne.litgateway.com:7370',
-    'https://cayenne.litgateway.com:7371',
-    'https://cayenne.litgateway.com:7372',
+    `${CAYENNE_URL}:7370'`,
+    `${CAYENNE_URL}:7371'`,
+    `${CAYENNE_URL}:7372'`,
   ],
   [LitNetwork.Manzano]: [],
   [LitNetwork.Habanero]: [],

packages/core/src/lib/lit-core.ts

@@ -23,12 +23,14 @@ import {
   StakingStates,
   version,
   LIT_ENDPOINT,
+  CAYENNE_URL,
 } from '@lit-protocol/constants';
 import { LitContracts } from '@lit-protocol/contracts-sdk';
 import { checkSevSnpAttestation, computeHDPubKey } from '@lit-protocol/crypto';
 import {
   bootstrapLogManager,
   executeWithRetry,
+  getIpAddress,
   isBrowser,
   isNode,
   log,
@@ -259,13 +261,34 @@ export class LitCore {
         this.config.litNetwork
       );
 
+      const minNodeCount = (
+        await LitContracts.getMinNodeCount(this.config.litNetwork)
+      ).toNumber();
+
+      const bootstrapUrls = await LitContracts.getValidators(
+        this.config.litNetwork
+      );
+
+      /**
+       * FIXME: We need this reformatting because the Cayenne network is not able to handle the node address as a URL.
+       * from: https://cayenne.litgateway.com
+       * to: http://207.244.70.36:7474
+       */
+      const remappedBootstrapUrls = await Promise.all(
+        bootstrapUrls.map(async (url) => {
+          const rootDomain = CAYENNE_URL.replace('https://', '');
+          const ipAddress = await getIpAddress(rootDomain);
+          return `http://${ipAddress}:${new URL(url).port}`;
+        })
+      );
+
       // If the network is cayenne it is a centralized testnet, so we use a static config
       // This is due to staking contracts holding local ip / port contexts which are innacurate to the ip / port exposed to the world
-      this.config.bootstrapUrls = LIT_NETWORKS.cayenne;
+      this.config.bootstrapUrls = remappedBootstrapUrls;
       this.config.minNodeCount =
-        LIT_NETWORKS.cayenne.length == 2
+        remappedBootstrapUrls.length == 2
           ? 2
-          : (LIT_NETWORKS.cayenne.length * 2) / 3;
+          : (remappedBootstrapUrls.length * 2) / 3;
 
       /**
        * Here we are checking if a custom network defined with no node urls (bootstrap urls) defined

packages/lit-node-client-nodejs/src/lib/lit-node-client-nodejs.ts

@@ -2418,10 +2418,25 @@ const resourceAbilityRequests = [
     const signatures: SessionSigsMap = {};
 
     this.connectedNodes.forEach((nodeAddress: string) => {
-      const toSign: SessionSigningTemplate = {
-        ...signingTemplate,
-        nodeAddress,
-      };
+      let toSign: SessionSigningTemplate;
+
+      // FIXME: We need this reformatting because the Cayenne network is not able to handle the node address as a URL.
+      // We are converting back
+      // from: http://207.244.70.36:7474
+      // to: 127.0.0.1:7474
+      if (this.config.litNetwork === LitNetwork.Cayenne) {
+        const url = new URL(nodeAddress);
+        const newNodeAddress = `127.0.0.1:${url.port}`;
+        toSign = {
+          ...signingTemplate,
+          nodeAddress: newNodeAddress,
+        };
+      } else {
+        toSign = {
+          ...signingTemplate,
+          nodeAddress,
+        };
+      }
 
       const signedMessage = JSON.stringify(toSign);
 

packages/misc/src/lib/misc.spec.ts

@@ -4,7 +4,7 @@ global.TextEncoder = TextEncoder;
 // @ts-ignore
 global.TextDecoder = TextDecoder;
 
-import { LitErrorKind, LIT_ERROR } from '@lit-protocol/constants';
+import { LitErrorKind, LIT_ERROR, CAYENNE_URL } from '@lit-protocol/constants';
 import * as utilsModule from './misc';
 
 describe('utils', () => {
@@ -288,3 +288,12 @@ it('should not remove hex prefix if it is not present', () => {
 
   expect(result).toBe(expectedOutput);
 });
+
+it('should get ip address', async () => {
+  // polyfill fetch
+  const fetch = require('node-fetch');
+  global.fetch = fetch;
+
+  const ipAddres = await utilsModule.getIpAddress('cayenne.litgateway.com');
+  expect(ipAddres).toBe('1');
+});

packages/misc/src/lib/misc.ts

@@ -915,3 +915,26 @@ export function normalizeAndStringify(input: string): string {
     return normalizeAndStringify(unescaped);
   }
 }
+
+/**
+ * Retrieves the IP address associated with a given domain.
+ * @param domain - The domain for which to retrieve the IP address.
+ * @returns A Promise that resolves to the IP address.
+ * @throws If no IP address is found or if the domain name is invalid.
+ */
+export async function getIpAddress(domain: string): Promise<string> {
+  const apiURL = `https://dns.google/resolve?name=${domain}&type=A`;
+
+  try {
+    const response = await fetch(apiURL);
+    const data = await response.json();
+
+    if (data.Answer && data.Answer.length > 0) {
+      return data.Answer[0].data;
+    } else {
+      throw new Error('No IP Address found or bad domain name');
+    }
+  } catch (error: any) {
+    throw new Error(error);
+  }
+}