Feature/lit 3125 sdk for wrapping up walletx 2

.prettierignore

@@ -11,4 +11,5 @@
 /tmp
 /packages/*/dist
 .nx
-tools
+tools
+**/*/dist

README.md

@@ -80,6 +80,7 @@ If you're a tech-savvy user and wish to utilize only specific submodules that ou
 | [@lit-protocol/sev-snp-utils-sdk](https://github.com/LIT-Protocol/js-sdk/tree/master/packages/sev-snp-utils-sdk)                 | ![sev-snp-utils-sdk](https://img.shields.io/badge/-universal-8A6496 'sev-snp-utils-sdk')                 | <a target="_blank" href="https://www.npmjs.com/package/@lit-protocol/sev-snp-utils-sdk"><img src="https://img.shields.io/npm/v/@lit-protocol/sev-snp-utils-sdk"/></a>                 |
 | [@lit-protocol/types](https://github.com/LIT-Protocol/js-sdk/tree/master/packages/types)                                         | ![types](https://img.shields.io/badge/-universal-8A6496 'types')                                         | <a target="_blank" href="https://www.npmjs.com/package/@lit-protocol/types"><img src="https://img.shields.io/npm/v/@lit-protocol/types"/></a>                                         |
 | [@lit-protocol/uint8arrays](https://github.com/LIT-Protocol/js-sdk/tree/master/packages/uint8arrays)                             | ![uint8arrays](https://img.shields.io/badge/-universal-8A6496 'uint8arrays')                             | <a target="_blank" href="https://www.npmjs.com/package/@lit-protocol/uint8arrays"><img src="https://img.shields.io/npm/v/@lit-protocol/uint8arrays"/></a>                             |
+| [@lit-protocol/wrapped-keys](https://github.com/LIT-Protocol/js-sdk/tree/master/packages/wrapped-keys)                           | ![wrapped-keys](https://img.shields.io/badge/-universal-8A6496 'wrapped-keys')                           | <a target="_blank" href="https://www.npmjs.com/package/@lit-protocol/wrapped-keys"><img src="https://img.shields.io/npm/v/@lit-protocol/wrapped-keys"/></a>                           |
 | [@lit-protocol/auth-browser](https://github.com/LIT-Protocol/js-sdk/tree/master/packages/auth-browser)                           | ![auth-browser](https://img.shields.io/badge/-browser-E98869 'auth-browser')                             | <a target="_blank" href="https://www.npmjs.com/package/@lit-protocol/auth-browser"><img src="https://img.shields.io/npm/v/@lit-protocol/auth-browser"/></a>                           |
 | [@lit-protocol/misc-browser](https://github.com/LIT-Protocol/js-sdk/tree/master/packages/misc-browser)                           | ![misc-browser](https://img.shields.io/badge/-browser-E98869 'misc-browser')                             | <a target="_blank" href="https://www.npmjs.com/package/@lit-protocol/misc-browser"><img src="https://img.shields.io/npm/v/@lit-protocol/misc-browser"/></a>                           |
 

lerna.json

@@ -2,5 +2,5 @@
   "$schema": "node_modules/lerna/schemas/lerna-schema.json",
   "useNx": true,
   "useWorkspaces": true,
-  "version": "6.0.3"
+  "version": "6.0.3-wrapped-keys.beta.5"
 }

local-tests/setup/session-sigs/get-pkp-session-sigs.ts

@@ -8,7 +8,8 @@ import { TinnyPerson } from '../tinny-person';
 export const getPkpSessionSigs = async (
   devEnv: TinnyEnvironment,
   alice: TinnyPerson,
-  resourceAbilityRequests?: LitResourceAbilityRequest[]
+  resourceAbilityRequests?: LitResourceAbilityRequest[],
+  expiration?: string
 ) => {
   if (devEnv.litNodeClient.config.litNetwork === LitNetwork.Manzano) {
     console.warn(
@@ -31,6 +32,7 @@ export const getPkpSessionSigs = async (
   const pkpSessionSigs = await devEnv.litNodeClient.getPkpSessionSigs({
     pkpPublicKey: alice.authMethodOwnedPkp.publicKey,
     authMethods: [alice.authMethod],
+    expiration,
     resourceAbilityRequests: _resourceAbilityRequests,
 
     // -- only add this for manzano network

local-tests/setup/tinny-environment.ts

@@ -365,6 +365,29 @@ export class TinnyEnvironment {
   }
   //============= END SHIVA ENDPOINTS =============
 
+  /**
+   * Sends funds from the current wallet to the specified wallet address.
+   * @param walletAddress - The address of the recipient wallet.
+   * @param amount - The amount of funds to send (default: '0.001').
+   * @throws If there is an error sending the funds.
+   */
+  getFunds = async (walletAddress: string, amount = '0.001') => {
+    try {
+      const privateKey = await this.getAvailablePrivateKey();
+      const provider = new ethers.providers.JsonRpcBatchProvider(this.rpc);
+      const wallet = new ethers.Wallet(privateKey.privateKey, provider);
+
+      const tx = await wallet.sendTransaction({
+        to: walletAddress,
+        value: ethers.utils.parseEther(amount),
+      });
+
+      await tx.wait();
+    } catch (e) {
+      throw new Error(`Failed to send funds to ${walletAddress}: ${e}`);
+    }
+  };
+
   /**
    * Context: the reason this is created instead of individually is because we can't allocate capacity beyond the global
    * max capacity.

local-tests/setup/tinny-utils.ts

@@ -31,3 +31,17 @@ export async function stringToIpfsHash(input: string): Promise<string> {
 
   return ipfsHash;
 }
+
+export function randomSolanaPrivateKey() {
+  const BASE58_ALPHABET =
+    '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+  const SOLANA_PRIVATE_KEY_LENGTH = 88;
+
+  let result = '';
+  const charactersLength = BASE58_ALPHABET.length;
+  for (let i = 0; i < SOLANA_PRIVATE_KEY_LENGTH; i++) {
+    const randomIndex = Math.floor(Math.random() * charactersLength);
+    result += BASE58_ALPHABET.charAt(randomIndex);
+  }
+  return result;
+}

local-tests/test.ts

@@ -83,12 +83,73 @@ import { testExecuteJsSignAndCombineEcdsa } from './tests/testExecuteJsSignAndCo
 import { testExecutJsDecryptAndCombine } from './tests/testExecuteJsDecryptAndCombine';
 import { testExecuteJsBroadcastAndCollect } from './tests/testExecuteJsBroadcastAndCollect';
 
+import { testEthereumSignMessageGeneratedKey } from './tests/testEthereumSignMessageGeneratedKey';
+import { testEthereumBroadcastTransactionGeneratedKey } from './tests/testEthereumBroadcastTransactionGeneratedKey';
+import { testEthereumSignMessageWrappedKey } from './tests/testEthereumSignMessageWrappedKey';
+import { testFailEthereumSignTransactionWrappedKeyInvalidDecryption } from './tests/testFailEthereumSignTransactionWrappedKeyInvalidDecryption';
+import { testEthereumSignTransactionWrappedKey } from './tests/testEthereumSignTransactionWrappedKey';
+import { testFailEthereumSignTransactionWrappedKeyWithInvalidParam } from './tests/testFailEthereumSignTransactionWrappedKeyWithInvalidParam';
+import { testFailEthereumSignTransactionWrappedKeyWithMissingParam } from './tests/testFailEthereumSignTransactionWrappedKeyWithMissingParam';
+import { testEthereumBroadcastTransactionWrappedKey } from './tests/testEthereumBroadcastTransactionWrappedKey';
+import { testEthereumBroadcastWrappedKeyWithFetchGasParams } from './tests/testEthereumBroadcastWrappedKeyWithFetchGasParams';
+import { testFailEthereumBroadcastTransactionWrappedKeysInsufficientFunds } from './tests/testFailEthereumBroadcastTransactionWrappedKeysInsufficientFunds';
+import { testImportWrappedKey } from './tests/testImportWrappedKey';
+import { testGenerateEthereumWrappedKey } from './tests/testGenerateEthereumWrappedKey';
+import { testGenerateSolanaWrappedKey } from './tests/testGenerateSolanaWrappedKey';
+import { testFailImportWrappedKeysWithSamePkp } from './tests/testFailImportWrappedKeysWithSamePkp';
+import { testFailImportWrappedKeysWithSamePrivateKey } from './tests/testFailImportWrappedKeysWithSamePrivateKey';
+import { testFailImportWrappedKeysWithEoaSessionSig } from './tests/testFailImportWrappedKeysWithEoaSessionSig';
+import { testFailImportWrappedKeysWithMaxExpirySessionSig } from './tests/testFailImportWrappedKeysWithMaxExpirySessionSig';
+import { testFailImportWrappedKeysWithInvalidSessionSig } from './tests/testFailImportWrappedKeysWithInvalidSessionSig';
+import { testFailImportWrappedKeysWithExpiredSessionSig } from './tests/testFailImportWrappedKeysWithExpiredSessionSig';
+import { testExportWrappedKey } from './tests/testExportWrappedKey';
+import { testSignMessageWithSolanaEncryptedKey } from './tests/testSignMessageWithSolanaEncryptedKey';
+import { testSignTransactionWithSolanaEncryptedKey } from './tests/testSignTransactionWithSolanaEncryptedKey';
+
 (async () => {
   console.log('[𐬺🧪 Tinny𐬺] Running tests...');
   const devEnv = new TinnyEnvironment();
 
   await devEnv.init();
 
+  const wrappedKeysTests = {
+    // -- valid cases
+    testEthereumSignMessageGeneratedKey,
+    testEthereumBroadcastTransactionGeneratedKey,
+    testEthereumSignMessageWrappedKey,
+    testEthereumSignTransactionWrappedKey,
+    testEthereumBroadcastTransactionWrappedKey,
+    testEthereumBroadcastWrappedKeyWithFetchGasParams,
+
+    // -- generate wrapped keys
+    testGenerateEthereumWrappedKey,
+    testGenerateSolanaWrappedKey,
+
+    // -- import wrapped keys
+    testImportWrappedKey,
+
+    // -- export wrapped keys
+    testExportWrappedKey,
+
+    // -- solana wrapped keys
+    testSignMessageWithSolanaEncryptedKey,
+    testSignTransactionWithSolanaEncryptedKey,
+
+    // -- invalid cases
+    testFailEthereumSignTransactionWrappedKeyWithMissingParam,
+    testFailEthereumSignTransactionWrappedKeyWithInvalidParam,
+    testFailEthereumSignTransactionWrappedKeyInvalidDecryption,
+    testFailEthereumBroadcastTransactionWrappedKeysInsufficientFunds,
+
+    // -- import wrapped keys
+    testFailImportWrappedKeysWithSamePkp,
+    testFailImportWrappedKeysWithSamePrivateKey,
+    testFailImportWrappedKeysWithEoaSessionSig,
+    testFailImportWrappedKeysWithMaxExpirySessionSig,
+    testFailImportWrappedKeysWithInvalidSessionSig,
+    testFailImportWrappedKeysWithExpiredSessionSig,
+  };
+
   const eoaSessionSigsTests = {
     testUseEoaSessionSigsToExecuteJsSigning,
     testUseEoaSessionSigsToPkpSign,
@@ -233,6 +294,8 @@ import { testExecuteJsBroadcastAndCollect } from './tests/testExecuteJsBroadcast
       ...litActionCombiningTests.broadcastAndCombine,
       ...litActionCombiningTests.decryptAndCombine,
       ...litActionCombiningTests.ecdsaSignAndCombine,
+
+      ...wrappedKeysTests,
     },
     devEnv,
   };

local-tests/tests/testEthereumBroadcastTransactionGeneratedKey.ts

@@ -0,0 +1,84 @@
+import { log } from '@lit-protocol/misc';
+import { ethers } from 'ethers';
+import { TinnyEnvironment } from 'local-tests/setup/tinny-environment';
+import { api, EthereumLitTransaction } from '@lit-protocol/wrapped-keys';
+import { getPkpSessionSigs } from 'local-tests/setup/session-sigs/get-pkp-session-sigs';
+
+const { signTransactionWithEncryptedKey, generatePrivateKey } = api;
+
+/**
+ * Test Commands:
+ * ✅ NETWORK=cayenne yarn test:local --filter=testEthereumBroadcastTransactionGeneratedKey
+ * ✅ NETWORK=manzano yarn test:local --filter=testEthereumBroadcastTransactionGeneratedKey
+ * ✅ NETWORK=localchain yarn test:local --filter=testEthereumBroadcastTransactionGeneratedKey
+ */
+export const testEthereumBroadcastTransactionGeneratedKey = async (
+  devEnv: TinnyEnvironment
+) => {
+  const alice = await devEnv.createRandomPerson();
+
+  const pkpSessionSigs = await getPkpSessionSigs(
+    devEnv,
+    alice,
+    null,
+    new Date(Date.now() + 1000 * 60 * 10).toISOString()
+  ); // 10 mins expiry
+
+  console.log(pkpSessionSigs);
+
+  const { pkpAddress, generatedPublicKey } = await generatePrivateKey({
+    pkpSessionSigs,
+    network: 'evm',
+    litNodeClient: devEnv.litNodeClient,
+  });
+
+  const generatedKeysWalletAddress =
+    ethers.utils.computeAddress(generatedPublicKey);
+  console.log(`Sending funds to ${generatedKeysWalletAddress}`);
+  await devEnv.getFunds(generatedKeysWalletAddress, '0.005');
+
+  const alicePkpAddress = alice.authMethodOwnedPkp.ethAddress;
+  if (pkpAddress !== alicePkpAddress) {
+    throw new Error(
+      `Received address: ${pkpAddress} doesn't match Alice's PKP address: ${alicePkpAddress}`
+    );
+  }
+
+  const pkpSessionSigsSigning = await getPkpSessionSigs(
+    devEnv,
+    alice,
+    null,
+    new Date(Date.now() + 1000 * 60 * 10).toISOString()
+  ); // 10 mins expiry
+
+  console.log(pkpSessionSigsSigning);
+
+  const unsignedTransaction: EthereumLitTransaction = {
+    toAddress: alice.wallet.address,
+    value: '0.0001', // in ethers (Lit tokens)
+    chainId: 175177, // Chronicle
+    gasPrice: '0.001',
+    gasLimit: 30000,
+    dataHex: ethers.utils.hexlify(
+      ethers.utils.toUtf8Bytes('Test transaction from Alice to bob')
+    ),
+    chain: 'chronicleTestnet',
+  };
+
+  const signedTx = await signTransactionWithEncryptedKey({
+    pkpSessionSigs: pkpSessionSigsSigning,
+    network: 'evm',
+    unsignedTransaction,
+    broadcast: true,
+    litNodeClient: devEnv.litNodeClient,
+  });
+
+  console.log('signedTx');
+  console.log(signedTx);
+
+  if (!ethers.utils.isHexString(signedTx)) {
+    throw new Error(`signedTx isn't hex: ${signedTx}`);
+  }
+
+  log('✅ testEthereumBroadcastTransactionGeneratedKey');
+};

local-tests/tests/testEthereumBroadcastTransactionWrappedKey.ts

@@ -0,0 +1,89 @@
+import { log } from '@lit-protocol/misc';
+import { ethers } from 'ethers';
+import { TinnyEnvironment } from 'local-tests/setup/tinny-environment';
+import { api, EthereumLitTransaction } from '@lit-protocol/wrapped-keys';
+import { getPkpSessionSigs } from 'local-tests/setup/session-sigs/get-pkp-session-sigs';
+
+const { importPrivateKey, signTransactionWithEncryptedKey } = api;
+
+/**
+ * Test Commands:
+ * ✅ NETWORK=cayenne yarn test:local --filter=testEthereumBroadcastTransactionWrappedKey
+ * ✅ NETWORK=manzano yarn test:local --filter=testEthereumBroadcastTransactionWrappedKey
+ * ✅ NETWORK=localchain yarn test:local --filter=testEthereumBroadcastTransactionWrappedKey
+ */
+export const testEthereumBroadcastTransactionWrappedKey = async (
+  devEnv: TinnyEnvironment
+) => {
+  const alice = await devEnv.createRandomPerson();
+
+  const pkpSessionSigs = await getPkpSessionSigs(
+    devEnv,
+    alice,
+    null,
+    new Date(Date.now() + 1000 * 60 * 10).toISOString()
+  ); // 10 mins expiry
+
+  console.log(pkpSessionSigs);
+
+  const wrappedKeysWallet = ethers.Wallet.createRandom();
+  const wrappedKeysWalletPrivateKey = wrappedKeysWallet.privateKey;
+
+  const wrappedKeysWalletAddress = wrappedKeysWallet.address;
+  console.log(`Sending funds to ${wrappedKeysWalletAddress}`);
+  await devEnv.getFunds(wrappedKeysWallet.address, '0.005');
+
+  const pkpAddress = await importPrivateKey({
+    pkpSessionSigs,
+    privateKey: wrappedKeysWalletPrivateKey,
+    litNodeClient: devEnv.litNodeClient,
+    publicKey: '0xdeadbeef',
+    keyType: 'K256',
+  });
+
+  const alicePkpAddress = alice.authMethodOwnedPkp.ethAddress;
+  if (pkpAddress !== alicePkpAddress) {
+    throw new Error(
+      `Received address: ${pkpAddress} doesn't match Alice's PKP address: ${alicePkpAddress}`
+    );
+  }
+
+  const pkpSessionSigsSigning = await getPkpSessionSigs(
+    devEnv,
+    alice,
+    null,
+    new Date(Date.now() + 1000 * 60 * 10).toISOString()
+  ); // 10 mins expiry
+
+  console.log(pkpSessionSigsSigning);
+
+  const unsignedTransaction: EthereumLitTransaction = {
+    toAddress: alice.wallet.address,
+    value: '0.0001', // in ethers (Lit tokens)
+    chainId: 175177, // Chronicle
+    gasPrice: '0.001',
+    gasLimit: 30000,
+    dataHex: ethers.utils.hexlify(
+      ethers.utils.toUtf8Bytes('Test transaction from Alice to bob')
+    ),
+    chain: 'chronicleTestnet',
+  };
+
+  const signedTx = await signTransactionWithEncryptedKey({
+    pkpSessionSigs: pkpSessionSigsSigning,
+    network: 'evm',
+    unsignedTransaction,
+    broadcast: true,
+    litNodeClient: devEnv.litNodeClient,
+  });
+
+  console.log('signedTx');
+  console.log(signedTx);
+
+  // TODO: Get the raw input from the tx hash, convert it to UTF-8 and assert that it contains "Test transaction from Alice to bob"
+  if (!ethers.utils.isHexString(signedTx)) {
+    throw new Error(`signedTx isn't hex: ${signedTx}`);
+  }
+
+  log('✅ testEthereumBroadcastTransactionWrappedKey');
+};