@gvnrdao/dh-lit-actions 0.0.14 → 0.0.15

package/out/authorization-dummy-b.hash

@@ -0,0 +1 @@
+1fe87da4a194b745c0bfe18364a9470a07ac33500461457b5baa5c425df8e882

package/out/authorization-dummy-b.js

@@ -0,0 +1,43 @@
+(() => {
+  // src/authorization-dummy-b.ts
+  var authorizationGoB = async () => {
+    try {
+      const message = globalThis.messageToSign || "diamond-hands-test-signature-b";
+      if (!globalThis.publicKey) {
+        Lit.Actions.setResponse({
+          response: JSON.stringify({
+            success: false,
+            error: "PKP public key not available"
+          })
+        });
+        return;
+      }
+      const signature = await Lit.Actions.signEcdsa({
+        toSign: ethers.utils.arrayify(
+          ethers.utils.keccak256(ethers.utils.toUtf8Bytes(message))
+        ),
+        publicKey: globalThis.publicKey,
+        sigName: "dummySig"
+      });
+      Lit.Actions.setResponse({
+        response: JSON.stringify({
+          success: true,
+          signature,
+          message,
+          pkpPublicKey: globalThis.publicKey,
+          timestamp: Date.now(),
+          action: "dummy-authorization-sign-b"
+        })
+      });
+    } catch (error) {
+      Lit.Actions.setResponse({
+        response: JSON.stringify({
+          success: false,
+          error: error.message || error.toString(),
+          timestamp: Date.now()
+        })
+      });
+    }
+  };
+  authorizationGoB();
+})();

package/out/authorization-dummy.hash

@@ -0,0 +1 @@
+dea7f902cb3991f6c86c79afbe2b8a9e0d9208af4d6762f5985a71908164c461

package/out/authorization-dummy.js

@@ -0,0 +1,63 @@
+(() => {
+  // src/authorization-dummy.ts
+  var authorizationGo = async () => {
+    try {
+      if (!globalThis.publicKey) {
+        Lit.Actions.setResponse({
+          response: JSON.stringify({
+            success: false,
+            error: "PKP public key not available"
+          })
+        });
+        return;
+      }
+      const rawToSign = globalThis.toSign;
+      const messageToSign = globalThis.messageToSign || "diamond-hands-test-signature";
+      let toSignData;
+      let signatureType;
+      if (rawToSign) {
+        if (typeof rawToSign === "string") {
+          toSignData = ethers.utils.arrayify(rawToSign);
+        } else if (rawToSign instanceof Uint8Array) {
+          toSignData = rawToSign;
+        } else if (Array.isArray(rawToSign)) {
+          toSignData = new Uint8Array(rawToSign);
+        } else {
+          throw new Error("Invalid toSign format");
+        }
+        signatureType = "bitcoin-raw-bytes";
+      } else {
+        toSignData = ethers.utils.arrayify(
+          ethers.utils.keccak256(ethers.utils.toUtf8Bytes(messageToSign))
+        );
+        signatureType = "ethereum-message-hash";
+      }
+      const signature = await Lit.Actions.signEcdsa({
+        toSign: toSignData,
+        publicKey: globalThis.publicKey,
+        sigName: "dummySig"
+      });
+      Lit.Actions.setResponse({
+        response: JSON.stringify({
+          success: true,
+          signature,
+          signatureType,
+          message: messageToSign,
+          rawDataSigned: rawToSign ? true : false,
+          pkpPublicKey: globalThis.publicKey,
+          timestamp: Date.now(),
+          action: "dummy-authorization-sign"
+        })
+      });
+    } catch (error) {
+      Lit.Actions.setResponse({
+        response: JSON.stringify({
+          success: false,
+          error: error.message || error.toString(),
+          timestamp: Date.now()
+        })
+      });
+    }
+  };
+  authorizationGo();
+})();

package/out/pkp-validator-datil.hash

@@ -0,0 +1 @@
+a896d4cf1366bfbc789006b66545b0080b841b92f539dfcc28c562ba74344b00

package/out/pkp-validator-datil.js

@@ -0,0 +1,231 @@
+(() => {
+  // src/pkp-validator-datil.ts
+  var go = async () => {
+    const targetPkpTokenId = globalThis.targetPkpTokenId;
+    const expectedCid = globalThis.expectedCid;
+    const network = globalThis.network;
+    try {
+      if (!targetPkpTokenId) {
+        throw new Error("targetPkpTokenId is required in parameters");
+      }
+      if (!expectedCid) {
+        throw new Error("expectedCid is required in parameters");
+      }
+      console.log("\n\u{1F512} PKP SECURITY VALIDATION");
+      console.log(
+        "   Using EXACT same logic as validatePKPSecurity test function"
+      );
+      console.log("   Making direct smart contract calls to verify security");
+      console.log(`   Target PKP: ${targetPkpTokenId}`);
+      console.log(`   Expected CID: ${expectedCid}`);
+      console.log(`   Network: ${network}`);
+      const LIT_DATIL_TEST_CONTRACTS = {
+        PKPNFT: "0x6a0f439f064B7167A8Ea6B22AcC07ae5360ee0d1",
+        PKPPermissions: "0x60C1ddC8b9e38F730F0e7B70A2F84C1A98A69167"
+      };
+      const LIT_DATIL_CONTRACTS = {
+        PKPNFT: "0x487A9D096BB4B7Ac1520Cb12370e31e677B175EA",
+        PKPPermissions: "0x213Db6E1446928E19588269bEF7dFc9187c4829A"
+      };
+      const LIT_CONTRACTS = network === "datil-test" ? LIT_DATIL_TEST_CONTRACTS : LIT_DATIL_CONTRACTS;
+      console.log("\n\u{1F50D} Step 1: PKP Existence Check...");
+      const existsCalldata = ethers.utils.concat([
+        ethers.utils.id("exists(uint256)").substring(0, 10),
+        // function selector
+        ethers.utils.defaultAbiCoder.encode(["uint256"], [targetPkpTokenId])
+      ]);
+      const existsCall = {
+        to: LIT_CONTRACTS.PKPNFT,
+        data: ethers.utils.hexlify(existsCalldata)
+      };
+      const existsRpcPayload = {
+        method: "eth_call",
+        params: [existsCall, "latest"],
+        id: 1,
+        jsonrpc: "2.0"
+      };
+      const existsResponse = await fetch(
+        "https://yellowstone-rpc.litprotocol.com",
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(existsRpcPayload)
+        }
+      );
+      const existsResult = await existsResponse.json();
+      if (existsResult.error) {
+        throw new Error(
+          `RPC Error checking exists: ${existsResult.error.message}`
+        );
+      }
+      const exists = ethers.utils.defaultAbiCoder.decode(
+        ["bool"],
+        existsResult.result
+      )[0];
+      console.log(`   PKP exists: ${exists}`);
+      console.log("\n\u{1F50D} Step 2: PKP Immutability Check...");
+      const ownerOfCalldata = ethers.utils.concat([
+        ethers.utils.id("ownerOf(uint256)").substring(0, 10),
+        // function selector
+        ethers.utils.defaultAbiCoder.encode(["uint256"], [targetPkpTokenId])
+      ]);
+      const ownerOfCall = {
+        to: LIT_CONTRACTS.PKPNFT,
+        data: ethers.utils.hexlify(ownerOfCalldata)
+      };
+      const ownerOfRpcPayload = {
+        method: "eth_call",
+        params: [ownerOfCall, "latest"],
+        id: 2,
+        jsonrpc: "2.0"
+      };
+      let owner = "0x0000000000000000000000000000000000000000";
+      let isImmutable = false;
+      if (exists) {
+        const ownerOfResponse = await fetch(
+          "https://yellowstone-rpc.litprotocol.com",
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(ownerOfRpcPayload)
+          }
+        );
+        const ownerOfResult = await ownerOfResponse.json();
+        if (ownerOfResult.error) {
+          throw new Error(
+            `RPC Error checking owner: ${ownerOfResult.error.message}`
+          );
+        }
+        owner = ethers.utils.defaultAbiCoder.decode(
+          ["address"],
+          ownerOfResult.result
+        )[0];
+        const BURN_ADDRESS = "0x000000000000000000000000000000000000dEaD";
+        isImmutable = owner.toLowerCase() === BURN_ADDRESS.toLowerCase();
+      }
+      console.log(`   PKP owner: ${owner}`);
+      console.log(`   Is immutable (burned to dead address): ${isImmutable}`);
+      console.log("\n\u{1F510} Step 3: Authorization Check...");
+      const getPermittedActionsCalldata = ethers.utils.concat([
+        ethers.utils.id("getPermittedActions(uint256)").substring(0, 10),
+        // function selector
+        ethers.utils.defaultAbiCoder.encode(["uint256"], [targetPkpTokenId])
+      ]);
+      const getPermittedActionsCall = {
+        to: LIT_CONTRACTS.PKPPermissions,
+        data: ethers.utils.hexlify(getPermittedActionsCalldata)
+      };
+      const getPermittedActionsRpcPayload = {
+        method: "eth_call",
+        params: [getPermittedActionsCall, "latest"],
+        id: 3,
+        jsonrpc: "2.0"
+      };
+      let actionsBytes = [];
+      let hasOnlyOneAction = false;
+      let matchesExpectedCID = false;
+      let foundCid = null;
+      if (exists) {
+        const getPermittedActionsResponse = await fetch(
+          "https://yellowstone-rpc.litprotocol.com",
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(getPermittedActionsRpcPayload)
+          }
+        );
+        const getPermittedActionsResult = await getPermittedActionsResponse.json();
+        if (getPermittedActionsResult.error) {
+          throw new Error(
+            `RPC Error getting permitted actions: ${getPermittedActionsResult.error.message}`
+          );
+        }
+        actionsBytes = ethers.utils.defaultAbiCoder.decode(
+          ["bytes[]"],
+          getPermittedActionsResult.result
+        )[0];
+        hasOnlyOneAction = actionsBytes.length === 1;
+        foundCid = actionsBytes[0] || null;
+        matchesExpectedCID = foundCid?.toLowerCase() === expectedCid.toLowerCase();
+      }
+      console.log(`   Permitted actions count: ${actionsBytes.length}`);
+      console.log(`   Actions bytes:`, actionsBytes);
+      console.log(`   Has exactly one action: ${hasOnlyOneAction}`);
+      console.log(`   Matches expected CID: ${matchesExpectedCID}`);
+      console.log(`   Expected CID: ${expectedCid}`);
+      console.log(`   Found CID: ${foundCid || "NONE"}`);
+      const allValid = exists && isImmutable && hasOnlyOneAction && matchesExpectedCID;
+      const validationSummary = {
+        pkpExists: `${exists} ${exists ? "\u2705" : "\u274C"}`,
+        pkpImmutable: `${isImmutable} ${isImmutable ? "\u2705" : "\u274C"}`,
+        singleAction: `${hasOnlyOneAction} ${hasOnlyOneAction ? "\u2705" : "\u274C"}`,
+        correctCID: `${matchesExpectedCID} ${matchesExpectedCID ? "\u2705" : "\u274C"}`,
+        overallSecurity: `${allValid} ${allValid ? "\u{1F512} SECURE" : "\u26A0\uFE0F INSECURE"}`
+      };
+      console.log("\n\u{1F512} COMPLETE SECURITY VALIDATION RESULT:");
+      console.log(`   PKP exists: ${validationSummary.pkpExists}`);
+      console.log(`   PKP immutable: ${validationSummary.pkpImmutable}`);
+      console.log(`   Single action: ${validationSummary.singleAction}`);
+      console.log(`   Correct CID: ${validationSummary.correctCID}`);
+      console.log(`   OVERALL SECURITY: ${validationSummary.overallSecurity}`);
+      if (!allValid) {
+        throw new Error(
+          "PKP security validation failed - not all conditions met"
+        );
+      }
+      console.log("\n\u{1F389} PKP IS FULLY SECURE!");
+      console.log("   \u2705 Exists on-chain");
+      console.log("   \u2705 Immutable (cannot be modified)");
+      console.log("   \u2705 Only authorized for expected LIT Action");
+      console.log("   \u{1F512} READY FOR PRODUCTION USE");
+      console.log("Step 3: Signing certification of PKP-CID relationship...");
+      const pkpIdBigInt = BigInt(`0x${targetPkpTokenId}`);
+      const pkpIdDecimal = `0x${pkpIdBigInt.toString(10)}`;
+      const cidHex = expectedCid.toLowerCase();
+      const certificationMessage = `PKP::${pkpIdDecimal}::CID::${cidHex}::SECURE`;
+      console.log(`   Certification message: ${certificationMessage}`);
+      const messageHash = ethers.utils.arrayify(
+        ethers.utils.hashMessage(certificationMessage)
+      );
+      console.log(`   Message hash (with Ethereum prefix): ${ethers.utils.hexlify(messageHash)}`);
+      const signature = await Lit.Actions.signEcdsa({
+        toSign: messageHash,
+        publicKey: globalThis.publicKey,
+        sigName: "pkpValidation"
+      });
+      console.log("\u2705 PKP-CID relationship certification signature generated");
+      Lit.Actions.setResponse({
+        response: JSON.stringify({
+          success: true,
+          validated: {
+            pkpTokenId: targetPkpTokenId,
+            exists,
+            immutable: isImmutable,
+            singleAction: hasOnlyOneAction,
+            correctCid: matchesExpectedCID,
+            expectedCid,
+            foundCidHex: actionsBytes[0]
+          },
+          validatorPkp: globalThis.publicKey,
+          signedMessage: certificationMessage,
+          signature,
+          timestamp: Date.now(),
+          network
+        })
+      });
+    } catch (error) {
+      console.error("\u274C PKP Validation failed:", error.message);
+      Lit.Actions.setResponse({
+        response: JSON.stringify({
+          success: false,
+          error: error.message || error.toString(),
+          targetPkpTokenId: globalThis.targetPkpTokenId || "unknown",
+          validatorPkp: globalThis.publicKey || "unknown",
+          timestamp: Date.now(),
+          network
+        })
+      });
+    }
+  };
+  go();
+})();

package/out/pkp-validator.hash

@@ -0,0 +1 @@
+6569485d942310b4b8095be09ca16cadc2ec88c737c27e32c3dac001998a5dfb