feat(pricing): add sign-session-key pricing support and product-aware sorting

- request `SIGN_SESSION_KEY` prices when fetching node data so the contract returns all four product columns
- extend pricing context schema to accept `SIGN_SESSION_KEY`  and re-sort nodes per product before slicing to threshold
- route PKP auth through `SIGN_SESSION_KEY` pricing while keeping custom auth on `LIT_ACTION`
- cover the new sort logic with a unit test to prove we now pick the cheapest validators for the requested product

Author: Ansonhkg

packages/auth/src/lib/AuthManager/authAdapters/getPkpAuthContextAdapter.ts

@@ -136,9 +136,9 @@ export async function getPkpAuthContextAdapter(
   const nodeUrls = litClientCtx.getMaxPricesForNodeProduct({
     nodePrices: nodePrices,
     userMaxPrice: litClientCtx.getUserMaxPrice({
-      product: 'LIT_ACTION',
+      product: 'SIGN_SESSION_KEY',
     }),
-    productId: PRODUCT_IDS['LIT_ACTION'],
+    productId: PRODUCT_IDS['SIGN_SESSION_KEY'],
     numRequiredNodes: threshold,
   });
 

packages/networks/src/networks/vNaga/shared/managers/LitChainClient/apis/rawContractApis/pricing/getNodesForRequest.ts

@@ -15,6 +15,7 @@ import {
  * - DECRYPTION (0): Used for decryption operations
  * - SIGN (1): Used for signing operations
  * - LA (2): Used for Lit Actions execution
+ * - SIGN_SESSION_KEY (3): Used for sign session key operations
  */
 export const PRODUCT_IDS = {
   DECRYPTION: 0n, // For decryption operations

packages/networks/src/networks/vNaga/shared/managers/pricing-manager/getMaxPricesForNodeProduct.spec.ts

@@ -0,0 +1,60 @@
+import { PRODUCT_IDS } from '@lit-protocol/constants';
+
+import { getMaxPricesForNodeProduct } from './getMaxPricesForNodeProduct';
+
+describe('getMaxPricesForNodeProduct', () => {
+  it('uses the requested product column when ranking nodes', () => {
+    const nodePrices = [
+      {
+        url: 'https://node-a',
+        prices: [80n, 5n, 9n, 30n],
+      },
+      {
+        url: 'https://node-b',
+        prices: [70n, 4n, 8n, 10n],
+      },
+      {
+        url: 'https://node-c',
+        prices: [60n, 3n, 7n, 20n],
+      },
+    ];
+
+    // Log the incoming order to show the encryption column is already sorted lowest-first.
+    console.log(
+      'incoming order',
+      nodePrices.map(({ url, prices }) => ({
+        url,
+        decryptionPrice: prices[PRODUCT_IDS.DECRYPTION],
+        signPrice: prices[PRODUCT_IDS.SIGN],
+        litActionPrice: prices[PRODUCT_IDS.LIT_ACTION],
+        signSessionKeyPrice: prices[PRODUCT_IDS.SIGN_SESSION_KEY],
+      }))
+    );
+
+    // Call the helper exactly like the SDK does: ask for SIGN_SESSION_KEY prices,
+    // pass the raw price feed output, and cap the request at two nodes.
+    const result = getMaxPricesForNodeProduct({
+      nodePrices,
+      userMaxPrice: 100n,
+      productId: PRODUCT_IDS.SIGN_SESSION_KEY,
+      numRequiredNodes: 2,
+    });
+
+    console.log(
+      'selected nodes',
+      result.map(({ url, price }) => ({ url, price }))
+    );
+
+    // After sorting the nodes by the session-key column, the helper should
+    // return node-b (10) and node-c (20) even though the original array was
+    // ordered by the decryption price column.
+    expect(result).toHaveLength(2);
+    expect(result[0].url).toBe('https://node-b');
+    expect(result[1].url).toBe('https://node-c');
+
+    // Base prices are taken from the SIGN_SESSION_KEY column (10 and 20)
+    // with the excess (100 - 30 = 70) split evenly.
+    expect(result[0].price).toBe(10n + 35n);
+    expect(result[1].price).toBe(20n + 35n);
+  });
+});

packages/networks/src/networks/vNaga/shared/managers/pricing-manager/getMaxPricesForNodeProduct.ts

@@ -28,10 +28,24 @@ export function getMaxPricesForNodeProduct({
   productId,
   numRequiredNodes,
 }: MaxPricesForNodes): { url: string; price: bigint }[] {
+  // Always evaluate pricing using the product-specific column so we truly pick
+  // the cheapest validators for that product (the upstream feed is sorted by
+  // prices[0]/decryption price only).
+  const sortedNodes = [...nodePrices].sort((a, b) => {
+    const priceA = a.prices[productId];
+    const priceB = b.prices[productId];
+
+    if (priceA === priceB) {
+      return 0;
+    }
+
+    return priceA < priceB ? -1 : 1;
+  });
+
   // If we don't need all nodes to service the request, only use the cheapest `n` of them
   const nodesToConsider = numRequiredNodes
-    ? nodePrices.slice(0, numRequiredNodes)
-    : nodePrices;
+    ? sortedNodes.slice(0, numRequiredNodes)
+    : sortedNodes;
 
   let totalBaseCost = 0n;
 

packages/networks/src/networks/vNaga/shared/managers/pricing-manager/schema.ts

@@ -4,7 +4,7 @@ import { PRODUCT_IDS } from './constants';
 
 export const PricingContextSchema = z
   .object({
-    product: z.enum(['DECRYPTION', 'SIGN', 'LIT_ACTION']),
+    product: z.enum(['DECRYPTION', 'SIGN', 'LIT_ACTION', 'SIGN_SESSION_KEY']),
     userMaxPrice: z.bigint().optional(),
     nodePrices: z.array(
       z.object({ url: z.string(), prices: z.array(z.bigint()) })