feat: it works! - add respond handling strategy

Author: Ansonhkg

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

@@ -3,25 +3,25 @@ export function parseCustomResources(nodeResponses: any) {
     return {
       signedMessage: item.siweMessage
     };
-  }).map((v: any) => {
+  }).map((v: any, i: number) => {
     const signedMessage = v.signedMessage;
     const urnLine = signedMessage.match(/urn:recap:[\w\d]+/)![0];
 
     const authContext = JSON.parse(atob(urnLine.split(':')[2])).att['lit-resolvedauthcontext://*']['Auth/Auth'][0]['auth_context'];
 
     const extractedCustomAuthResource = (authContext['customAuthResource']).slice(8, -2);
-    const formattedCustomAuthResource = extractedCustomAuthResource.replace(/\\"/g, '"');
+    const customAuthResources = extractedCustomAuthResource.replace(/\\"/g, '"');
     let result;
 
     try {
-      result = JSON.parse(formattedCustomAuthResource);
+      result = JSON.parse(customAuthResources);
     } catch (e) {
       result = extractedCustomAuthResource
     }
 
     return {
-      authContext,
-      formattedCustomAuthResource: result,
+      customAuthResources: result,
+      // authContext,
     };
-  }).find((item: any) => item.formattedCustomAuthResource !== 'undefined')))?.formattedCustomAuthResource
+  }).find((item: any) => item.customAuthResources !== 'undefined'))).customAuthResources;
 }

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

@@ -43,6 +43,7 @@ import {
   findMostCommonResponse,
   formatSessionSigs,
   hexPrefixed,
+  leastCommonString,
   log,
   logError,
   logErrorWithRequestId,
@@ -1881,8 +1882,8 @@ export class LitNodeClientNodeJs
 
     // -- resolve promises
     const numberToResolve = params?.handleAllResponses ? this.connectedNodes.size : this.config.minNodeCount;
+    log(`[signSessionKey] number of node promises to resolve:`, numberToResolve);
 
-    console.log("numberToResolve:", numberToResolve);
     let res;
     try {
       res = await this.handleNodePromises(
@@ -1896,19 +1897,14 @@ export class LitNodeClientNodeJs
     }
 
     // -- handle all responses
-    let customResources;
-
-
-    console.log("res:", res);
+    let customAuthResources;
 
     try {
-      customResources = parseCustomResources(res);
+      customAuthResources = parseCustomResources(res);
     } catch (e) {
       log(`Failed to parse custom resources, not a problem.`)
     }
 
-    console.log("customResources:", customResources);
-
     logWithRequestId(requestId, 'handleNodePromises res:', res);
 
     // -- case: promises rejected
@@ -2010,10 +2006,12 @@ export class LitNodeClientNodeJs
       );
     }
 
+    const commonStringStrategy = params?.strategy === 'mostCommon' ? mostCommonString : leastCommonString;
+
     const blsSignedData: BlsResponseData[] =
       validatedSignedDataList as BlsResponseData[];
 
-    const sigType = mostCommonString(blsSignedData.map((s) => s.curveType));
+    const sigType = commonStringStrategy(blsSignedData.map((s) => s.curveType));
     log(`[signSessionKey] sigType:`, sigType);
 
     const signatureShares = getBlsSignatures(blsSignedData);
@@ -2030,10 +2028,10 @@ export class LitNodeClientNodeJs
     const publicKey = removeHexPrefix(params.pkpPublicKey);
     log(`[signSessionKey] publicKey:`, publicKey);
 
-    const dataSigned = mostCommonString(blsSignedData.map((s) => s.dataSigned));
+    const dataSigned = commonStringStrategy(blsSignedData.map((s) => s.dataSigned));
     log(`[signSessionKey] dataSigned:`, dataSigned);
 
-    const mostCommonSiweMessage = mostCommonString(
+    const mostCommonSiweMessage = commonStringStrategy(
       blsSignedData.map((s) => s.siweMessage)
     );
 
@@ -2052,7 +2050,7 @@ export class LitNodeClientNodeJs
         derivedVia: 'lit.bls',
         signedMessage,
         address: computeAddress(hexPrefixed(publicKey)),
-        ...(customResources && { customResources: customResources })
+        ...(customAuthResources && { customAuthResources: customAuthResources })
       },
       pkpPublicKey: publicKey,
     };
@@ -2140,6 +2138,7 @@ export class LitNodeClientNodeJs
       ...(params.jsParams && { jsParams: params.jsParams }),
     });
 
+
     const needToResignSessionKey = await this.checkNeedToResignSessionKey({
       authSig,
       sessionKeyUri,

packages/misc/src/lib/misc.ts

@@ -65,6 +65,23 @@ export const mostCommonString = (arr: Array<any>): any => {
     .pop();
 };
 
+/**
+ *
+ * Find the element that occurs the least in an array
+ *
+ * @param { Array<any> } arr
+ * @returns { any } the element that appeared the least
+ */
+export const leastCommonString = (arr: Array<any>): any => {
+  return arr
+    .sort(
+      (a: any, b: any) =>
+        arr.filter((v: any) => v === b).length -
+        arr.filter((v: any) => v === a).length
+    )
+    .pop();
+};
+
 export const findMostCommonResponse = (responses: Array<object>): object => {
   const result: { [key: string]: any } = {};
 

packages/types/src/lib/interfaces.ts

@@ -1047,7 +1047,7 @@ export interface CreateCustomAuthMethodRequest {
 //     pub auth_sig: Option<AuthSigItem>,
 //     pub siwe_message: String,
 // }
-export interface SignSessionKeyProp extends LitActionSdkParams {
+export interface SignSessionKeyProp extends LitActionSdkParams, RespondHandling {
   /**
    * The serialized session key pair to sign. If not provided, a session key pair will be fetched from localStorge or generated.
    */
@@ -1091,11 +1091,6 @@ export interface SignSessionKeyProp extends LitActionSdkParams {
    * A LIT resource ability is a combination of a LIT resource and a LIT ability.
    */
   resourceAbilityRequests?: LitResourceAbilityRequest[];
-
-  /**
-   * By default, it handles minNodeCount of responses
-   */
-  handleAllResponses?: boolean;
 }
 
 export interface SignSessionKeyResponse {
@@ -1915,7 +1910,7 @@ export interface SignerLike {
 
 export interface GetPkpSessionSigs
   extends CommonGetSessionSigsProps,
-  LitActionSdkParams {
+  LitActionSdkParams, RespondHandling {
   pkpPublicKey: string;
 
   /**
@@ -1929,8 +1924,6 @@ export interface GetPkpSessionSigs
   authMethods?: AuthMethod[];
 
   ipfsOptions?: IpfsOptions;
-
-  handleAllResponses?: boolean;
 }
 
 /**
@@ -1950,12 +1943,19 @@ export type GetLitActionSessionSigs = CommonGetSessionSigsProps &
     })
   ) & {
     ipfsOptions?: IpfsOptions;
+  } & RespondHandling;
 
-    /**
-     * Special property to return all node responses
-     */
-    handleAllResponses?: boolean;
-  };
+export interface RespondHandling {
+  /**
+   * Weather to handle all responses or threshold/minNodeCount responses
+   */
+  handleAllResponses?: boolean;
+
+  /**
+   * Strategy to handle responses
+   */
+  strategy?: ResponseStrategy;
+}
 
 export interface SessionKeyCache {
   value: SessionKeyPair;

packages/wrapped-keys/src/lib/api/tria-batch-generate-private-keys.ts

@@ -67,19 +67,9 @@ export async function triaBatchGeneratePrivateKeys(
     accessControlConditions: [allowPkpAddressToDecrypt],
   };
 
-  // const { pkpSessionSigs, litNodeClient } = params;
-
-  // const sessionSig = getFirstSessionSig(pkpSessionSigs);
-  // const pkpAddress = getPkpAddressFromSessionSig(sessionSig);
-
-  // const allowPkpAddressToDecrypt = getPkpAccessControlCondition(pkpAddress);
-
-  // const { litActionCode, litActionIpfsCid } = getLitActionCodeOrCidCommon(
-  //   'batchGenerateEncryptedKeys'
-  // );
-
   try {
     litActionSessionSigs = await params.litNodeClient.getLitActionSessionSigs({
+      expiration: new Date(Date.now() + 1000 * 60 * 10).toISOString(),
       pkpPublicKey: params.pkpPublicKey,
       resourceAbilityRequests: [
         {
@@ -94,52 +84,56 @@ export async function triaBatchGeneratePrivateKeys(
       litActionIpfsId: params.ipfsId,
       jsParams: _jsParams,
       handleAllResponses: true,
+      strategy: 'leastCommon',
     });
   } catch (e) {
     throw new Error(`Error getting Lit Action Session Sigs: ${e}`);
   }
 
-  console.log("litActionSessionSigs:", litActionSessionSigs);
-
-  process.exit();
-
-  return { pkpAddress: pkpEthAddress, results: [] };
-
-  // TODO: Uncomment below
-  // const keyParamsBatch = actionResults.map((keyData) => {
-  //   const { generateEncryptedPrivateKey, network } = keyData;
-  //   return {
-  //     ...generateEncryptedPrivateKey,
-  //     keyType: getKeyTypeFromNetwork(network),
-  //   };
-  // });
-
-  // const { ids } = await storePrivateKeyBatch({
-  //   sessionSig,
-  //   storedKeyMetadataBatch: keyParamsBatch,
-  //   litNetwork: litNodeClient.config.litNetwork,
-  // });
-
-  // const results = actionResults.map(
-  //   (actionResult, ndx): BatchGeneratePrivateKeysActionResult => {
-  //     const {
-  //       generateEncryptedPrivateKey: { memo, publicKey },
-  //     } = actionResult;
-  //     const id = ids[ndx]; // Result of writes is in same order as provided
-
-  //     const signature = actionResult.signMessage?.signature;
-
-  //     return {
-  //       ...(signature ? { signMessage: { signature } } : {}),
-  //       generateEncryptedPrivateKey: {
-  //         memo: memo,
-  //         id,
-  //         generatedPublicKey: publicKey,
-  //         pkpAddress,
-  //       },
-  //     };
-  //   }
-  // );
-
-  // return { pkpAddress, results };
+  const firstSessionSig = Object.entries(litActionSessionSigs)[0][1];
+
+  const firstSignedMessage = JSON.parse(firstSessionSig.signedMessage);
+
+  const firstCapabilities = firstSignedMessage.capabilities[0];
+
+  const theCustomAuthResources = firstCapabilities.customAuthResources;
+
+  const pkpAddress = getPkpAddressFromSessionSig(firstSessionSig);
+
+  const keyParamsBatch = theCustomAuthResources.map((keyData: any) => {
+    const { generateEncryptedPrivateKey, network } = keyData;
+    return {
+      ...generateEncryptedPrivateKey,
+      keyType: getKeyTypeFromNetwork(network),
+    };
+  });
+
+  const { ids } = await storePrivateKeyBatch({
+    sessionSig: firstSessionSig,
+    storedKeyMetadataBatch: keyParamsBatch,
+    litNetwork: params.litNodeClient.config.litNetwork,
+  });
+
+  const results = theCustomAuthResources.map(
+    (actionResult: any, ndx: any): BatchGeneratePrivateKeysActionResult => {
+      const {
+        generateEncryptedPrivateKey: { memo, publicKey },
+      } = actionResult;
+      const id = ids[ndx]; // Result of writes is in same order as provided
+
+      const signature = actionResult.signMessage?.signature;
+
+      return {
+        ...(signature ? { signMessage: { signature } } : {}),
+        generateEncryptedPrivateKey: {
+          memo: memo,
+          id,
+          generatedPublicKey: publicKey,
+          pkpAddress,
+        },
+      };
+    }
+  );
+
+  return { pkpAddress, results };
 }

packages/wrapped-keys/src/lib/service-client/utils.ts

@@ -135,9 +135,8 @@ export async function makeRequest<T>({
     return result;
   } catch (e: unknown) {
     throw new Error(
-      `Request(${requestId}) for wrapped key failed. Error: ${
-        (e as Error).message
-        // @ts-expect-error Unknown, but `cause` is on `TypeError: fetch failed` errors
+      `Request(${requestId}) for wrapped key failed. Error: ${(e as Error).message
+      // @ts-expect-error Unknown, but `cause` is on `TypeError: fetch failed` errors
       }${e.cause ? ' - ' + e.cause : ''}`
     );
   }

tsconfig.json

@@ -10,15 +10,24 @@
     "importHelpers": true,
     "target": "ES2020",
     "module": "ES2020",
-    "lib": ["ES2020", "dom", "ES2021.String"],
+    "lib": [
+      "ES2020",
+      "dom",
+      "ES2021.String"
+    ],
     "skipLibCheck": true,
     "skipDefaultLibCheck": true,
     "baseUrl": ".",
     "allowSyntheticDefaultImports": true,
     "resolveJsonModule": true,
     "paths": {
-      "@lit-protocol/*": ["packages/*/src"]
+      "@lit-protocol/*": [
+        "packages/*/src"
+      ]
     }
   },
-  "exclude": ["node_modules", "tmp"]
-}
+  "exclude": [
+    "node_modules",
+    "tmp"
+  ]
+}