feat: add sign eth tx guide implementation

Author: madschristensen99

deno.lock

@@ -0,0 +1,164 @@
+import { LitNodeClient } from '@lit-protocol/lit-node-client';
+import { LIT_RPC, LIT_ABILITY } from "@lit-protocol/constants";
+import {
+  createSiweMessage,
+  generateAuthSig,
+  LitActionResource,
+} from "@lit-protocol/auth-helpers";
+import * as ethers from "ethers";
+
+// Utility function to get environment variables
+const getEnv = (name: string): string => {
+  const value = process.env[name];
+  if (!value) {
+    console.warn(`Environment variable ${name} is not set`);
+  }
+  return value || "";
+};
+
+// Environment variables
+const ETHEREUM_PRIVATE_KEY = getEnv("ETHEREUM_PRIVATE_KEY");
+
+// Define the Lit Action code for conditional signing
+const litActionCode = `
+async () =>  {
+  const signature = await Lit.Actions.signAndCombineEcdsa({
+    toSign,
+    publicKey,
+    sigName,
+  });
+
+  const jsonSignature = JSON.parse(signature);
+  jsonSignature.r = "0x" + jsonSignature.r.substring(2);
+  jsonSignature.s = "0x" + jsonSignature.s;
+  const hexSignature = ethers.utils.joinSignature(jsonSignature);
+
+  const signedTx = ethers.utils.serializeTransaction(
+    unsignedTransaction,
+    hexSignature
+  );
+
+  const recoveredAddress = ethers.utils.recoverAddress(toSign, hexSignature);
+  console.log("Recovered Address:", recoveredAddress);
+
+  const response = await Lit.Actions.runOnce(
+    { waitForResponse: true, name: "txnSender" },
+    async () => {
+      try {
+        const rpcUrl = await Lit.Actions.getRpcUrl({ chain });
+        const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
+        const transactionReceipt = await provider.sendTransaction(signedTx);
+
+        return \`Transaction Sent Successfully. Transaction Hash: \${transactionReceipt.hash}\`;
+      } catch (error) {
+        return \`Error: When sending transaction: \${error.message}\`;
+      }
+    }
+  );
+
+  Lit.Actions.setResponse({ response });
+};
+`;
+
+// Define the ethTxResult type with success and error properties
+interface ethTxResult {
+  response: any;
+  success: boolean;
+  error?: any;
+}
+
+/**
+ * Execute eth transaction inside a Lit Action
+ * @returns Result of the transaction
+ */
+export const signEthTx = async (): Promise<ethTxResult> => {
+  try {
+    // Create ethers wallet for signing
+    const ethersWallet = new ethers.Wallet(
+      ETHEREUM_PRIVATE_KEY,
+      new ethers.providers.JsonRpcProvider(LIT_RPC.CHRONICLE_YELLOWSTONE)
+    );
+    
+    const message = new Uint8Array(
+      await crypto.subtle.digest('SHA-256', new TextEncoder().encode('Hello world'))
+    );
+    
+    const litNodeClient = new LitNodeClient({
+      alertWhenUnauthorized: false,
+      litNetwork: "datil-dev",
+      debug: false,
+    });
+    
+    await litNodeClient.connect();
+    
+    const sessionSigs = await litNodeClient.getSessionSigs({
+      chain: "ethereum",
+      expiration: new Date(Date.now() + 1000 * 60 * 10).toISOString(), // 10 minutes
+      resourceAbilityRequests: [
+        {
+          resource: new LitActionResource("*"),
+          ability: LIT_ABILITY.LitActionExecution,
+        },
+      ],
+      authNeededCallback: async ({
+        uri,
+        expiration,
+        resourceAbilityRequests,
+      }) => {
+        const toSign = await createSiweMessage({
+          uri,
+          expiration,
+          resources: resourceAbilityRequests,
+          walletAddress: await ethersWallet.getAddress(),
+          nonce: await litNodeClient.getLatestBlockhash(),
+          litNodeClient,
+        });
+        return await generateAuthSig({
+          signer: ethersWallet,
+          toSign,
+        });
+      },
+    });
+    
+    const signatures = await litNodeClient.executeJs({
+      code: litActionCode,
+      sessionSigs,
+      // all jsParams can be used anywhere in your litActionCode
+      jsParams: {
+        toSign: message,
+        publicKey:
+          "0x02e5896d70c1bc4b4b4844458748fe0f936c7919d7968341e391fb6d82c258192e64",
+        sigName: "sig1",
+        // Add missing parameters that the Lit Action needs
+        unsignedTransaction: {
+          // You should populate this with a real transaction object
+          to: "0x0000000000000000000000000000000000000000",
+          value: ethers.utils.parseEther("0"),
+          nonce: 0,
+          gasLimit: 21000,
+          gasPrice: ethers.utils.parseUnits("50", "gwei"),
+          data: "0x",
+          chainId: 84532, // Base Sepolia testnet
+        },
+        chain: "ethereum",
+      },
+    });
+    
+    console.log("signatures: ", signatures);
+    
+    // Disconnect from the Lit Node network
+    await litNodeClient.disconnect();
+    
+    return {
+      response: signatures,
+      success: true
+    };
+  } catch (error) {
+    console.error("Error in signEthTx:", error);
+    return {
+      response: null,
+      success: false,
+      error
+    };
+  }
+};

exampleLitActions/src/signEthTx.ts

@@ -0,0 +1,33 @@
+import { expect } from 'chai';
+import { signEthTx } from '../src/signEthTx';
+
+describe('Lit Action ETH transaction test', function() {
+  // Increase timeout for Lit network operations
+  this.timeout(60000);
+
+  it('should execute an eth transaction inside a Lit Action', async function() {
+    const result = await signEthTx();
+    
+    // Check if the operation was successful
+    expect(result.success, 'Transaction should execute successfully').to.be.true;
+    
+    // Verify we have a response object
+    expect(result.response, 'Response should exist').to.not.be.null;
+    expect(result.response, 'Response should be an object').to.be.an('object');
+    
+    // If we have a success response, error should be undefined
+    if (result.success) {
+      expect(result.error, 'Error should be undefined on success').to.be.undefined;
+    } else {
+      // In case of failure, log the error for debugging
+      console.error('Transaction failed with error:', result.error);
+    }
+    
+    // Check the response structure based on actual output
+    if (result.success && result.response) {
+      expect(result.response, 'Should have success property').to.have.property('success');
+      expect(result.response, 'Should have signedData property').to.have.property('signedData');
+      expect(result.response, 'Should have decryptedData property').to.have.property('decryptedData');
+    }
+  });
+});

exampleLitActions/test/signEthTx.spec.ts

@@ -11,6 +11,7 @@
     "payment-delegation-db/**/*",
     "programmable-key-pairs/**/*",
     "session-signatures/**/*",
-    "wrapped-keys/**/*"
+    "wrapped-keys/**/*",
+    "exampleLitActions"
   ]
 }

lerna.json

@@ -10,7 +10,8 @@
     "payment-delegation-db/**/*",
     "programmable-key-pairs/**/*",
     "session-signatures/**/*",
-    "wrapped-keys/**/*"
+    "wrapped-keys/**/*",
+    "exampleLitActions"
   ],
   "devDependencies": {
     "@eslint/js": "^9.8.0",
@@ -45,5 +46,9 @@
   },
   "scripts": {
     "test:all": "lerna run test --stream"
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e",
+  "dependencies": {
+    "ethers": "^5.8.0"
   }
 }