@graphprotocol/hypergraph 0.0.1 → 0.0.2

package/src/connect/create-callback-params.ts

@@ -6,15 +6,18 @@ type CreateAuthUrlParams = {
   expiry: number;
   nonce: string;
   appId: string;
+  permissionId: string;
   appIdentityAddress: string;
   appIdentityAddressPrivateKey: string;
+  accountAddress: string;
   signaturePublicKey: string;
   signaturePrivateKey: string;
   encryptionPublicKey: string;
   encryptionPrivateKey: string;
   sessionToken: string;
   sessionTokenExpires: number;
-  spaces: { id: string }[];
+  privateSpaces: { id: string }[];
+  publicSpaces: { id: string }[];
 };
 
 export const createCallbackParams = ({ nonce, ephemeralPublicKey, ...rest }: CreateAuthUrlParams) => {

package/src/connect/identity-encryption.ts

@@ -67,7 +67,6 @@ const signatureMessage = (nonce: Uint8Array): string => {
 
 export const encryptIdentity = async (
   signer: Signer,
-  accountAddress: string,
   keys: IdentityKeys,
 ): Promise<{ ciphertext: string; nonce: string }> => {
   const nonce = randomBytes(32);
@@ -76,7 +75,7 @@ export const encryptIdentity = async (
 
   // Check that the signature is valid
   const valid = await verifyMessage({
-    address: accountAddress as Hex,
+    address: (await signer.getAddress()) as Hex,
     message,
     signature,
   });
@@ -97,18 +96,13 @@ export const encryptIdentity = async (
   return { ciphertext, nonce: bytesToHex(nonce) };
 };
 
-export const decryptIdentity = async (
-  signer: Signer,
-  accountAddress: string,
-  ciphertext: string,
-  nonce: string,
-): Promise<IdentityKeys> => {
+export const decryptIdentity = async (signer: Signer, ciphertext: string, nonce: string): Promise<IdentityKeys> => {
   const message = signatureMessage(hexToBytes(nonce));
   const signature = (await signer.signMessage(message)) as Hex;
 
   // Check that the signature is valid
   const valid = await verifyMessage({
-    address: accountAddress as Hex,
+    address: (await signer.getAddress()) as Hex,
     message,
     signature,
   });
@@ -141,9 +135,9 @@ export const decryptIdentity = async (
 
 export const encryptAppIdentity = async (
   signer: Signer,
-  accountAddress: string,
   appIdentityAddress: string,
   appIdentityAddressPrivateKey: string,
+  permissionId: string,
   keys: IdentityKeys,
 ): Promise<{ ciphertext: string; nonce: string }> => {
   const nonce = randomBytes(32);
@@ -152,7 +146,7 @@ export const encryptAppIdentity = async (
 
   // Check that the signature is valid
   const valid = await verifyMessage({
-    address: accountAddress as Hex,
+    address: (await signer.getAddress()) as Hex,
     message,
     signature,
   });
@@ -169,6 +163,7 @@ export const encryptAppIdentity = async (
     keys.signaturePrivateKey,
     appIdentityAddress,
     appIdentityAddressPrivateKey,
+    permissionId,
   ].join('\n');
   const keysMsg = new TextEncoder().encode(keysTxt);
   const ciphertext = encrypt(keysMsg, secretKey);
@@ -177,16 +172,15 @@ export const encryptAppIdentity = async (
 
 export const decryptAppIdentity = async (
   signer: Signer,
-  accountAddress: string,
   ciphertext: string,
   nonce: string,
-): Promise<Omit<PrivateAppIdentity, 'sessionToken' | 'sessionTokenExpires'>> => {
+): Promise<Omit<PrivateAppIdentity, 'sessionToken' | 'sessionTokenExpires' | 'accountAddress'>> => {
   const message = signatureMessage(hexToBytes(nonce));
   const signature = (await signer.signMessage(message)) as Hex;
 
   // Check that the signature is valid
   const valid = await verifyMessage({
-    address: accountAddress as Hex,
+    address: (await signer.getAddress()) as Hex,
     message,
     signature,
   });
@@ -220,6 +214,7 @@ export const decryptAppIdentity = async (
     signaturePrivateKey,
     appIdentityAddress,
     appIdentityAddressPrivateKey,
+    permissionId,
   ] = keysTxt.split('\n');
   return {
     encryptionPublicKey,
@@ -228,5 +223,6 @@ export const decryptAppIdentity = async (
     signaturePrivateKey,
     address: appIdentityAddress,
     addressPrivateKey: appIdentityAddressPrivateKey,
+    permissionId,
   };
 };

package/src/connect/index.ts

@@ -6,5 +6,5 @@ export * from './identity-encryption.js';
 export * from './login.js';
 export * from './parse-auth-params.js';
 export * from './parse-callback-params.js';
-export * from './prove-ownership.js';
+export * from './smart-account.js';
 export * from './types.js';

package/src/connect/login.ts

@@ -1,11 +1,19 @@
 import * as Schema from 'effect/Schema';
-import type { Address } from 'viem';
+import type { SmartAccountClient } from 'permissionless';
+import type { Address, Chain, Hex, WalletClient } from 'viem';
+import { proveIdentityOwnership } from '../identity/prove-ownership.js';
 import * as Messages from '../messages/index.js';
 import { store } from '../store-connect.js';
-import { storeAccountAddress, storeKeys } from './auth-storage.js';
+import { loadAccountAddress, storeAccountAddress, storeKeys, wipeAccountAddress } from './auth-storage.js';
 import { createIdentityKeys } from './create-identity-keys.js';
 import { decryptIdentity, encryptIdentity } from './identity-encryption.js';
-import { proveIdentityOwnership } from './prove-ownership.js';
+import {
+  type SmartAccountParams,
+  getSmartAccountWalletClient,
+  isSmartAccountDeployed,
+  smartAccountNeedsUpdate,
+  updateLegacySmartAccount,
+} from './smart-account.js';
 import type { IdentityKeys, Signer, Storage } from './types.js';
 
 export async function identityExists(accountAddress: string, syncServerUri: string) {
@@ -17,17 +25,24 @@ export async function identityExists(accountAddress: string, syncServerUri: stri
 
 export async function signup(
   signer: Signer,
+  walletClient: WalletClient,
+  smartAccountClient: SmartAccountClient,
   accountAddress: Address,
   syncServerUri: string,
   storage: Storage,
   identityToken: string,
 ) {
   const keys = createIdentityKeys();
-  const { ciphertext, nonce } = await encryptIdentity(signer, accountAddress, keys);
-  const { accountProof, keyProof } = await proveIdentityOwnership(signer, accountAddress, keys);
+  const { ciphertext, nonce } = await encryptIdentity(signer, keys);
+  const { accountProof, keyProof } = await proveIdentityOwnership(
+    walletClient,
+    smartAccountClient,
+    accountAddress,
+    keys,
+  );
 
   const req: Messages.RequestConnectCreateIdentity = {
-    keyBox: { accountAddress, ciphertext, nonce },
+    keyBox: { signer: await signer.getAddress(), accountAddress, ciphertext, nonce },
     accountProof,
     keyProof,
     signaturePublicKey: keys.signaturePublicKey,
@@ -49,9 +64,8 @@ export async function signup(
   if (!decoded.success) {
     throw new Error('Error creating identity');
   }
-  storeAccountAddress(storage, accountAddress);
   storeKeys(storage, accountAddress, keys);
-
+  storeAccountAddress(storage, accountAddress);
   return {
     accountAddress,
     keys,
@@ -66,9 +80,10 @@ export async function restoreKeys(
   identityToken: string,
 ) {
   const res = await fetch(new URL('/connect/identity/encrypted', syncServerUri), {
-    method: 'POST',
+    method: 'GET',
     headers: {
       'privy-id-token': identityToken,
+      'account-address': accountAddress,
       'Content-Type': 'application/json',
     },
   });
@@ -77,8 +92,9 @@ export async function restoreKeys(
     const decoded = Schema.decodeUnknownSync(Messages.ResponseIdentityEncrypted)(await res.json());
     const { keyBox } = decoded;
     const { ciphertext, nonce } = keyBox;
-    const keys = await decryptIdentity(signer, accountAddress, ciphertext, nonce);
+    const keys = await decryptIdentity(signer, ciphertext, nonce);
     storeKeys(storage, accountAddress, keys);
+    storeAccountAddress(storage, accountAddress);
     return {
       accountAddress,
       keys,
@@ -87,13 +103,77 @@ export async function restoreKeys(
   throw new Error(`Error fetching identity ${res.status}`);
 }
 
-export async function login(
-  signer: Signer,
-  accountAddress: Address,
-  syncServerUri: string,
-  storage: Storage,
-  identityToken: string,
-) {
+const getAndDeploySmartAccount = async (walletClient: WalletClient, rpcUrl: string, chain: Chain, storage: Storage) => {
+  const accountAddressFromStorage = loadAccountAddress(storage) as Hex;
+  const smartAccountParams: SmartAccountParams = {
+    owner: walletClient,
+    rpcUrl,
+    chain,
+  };
+  if (accountAddressFromStorage) {
+    smartAccountParams.address = accountAddressFromStorage;
+  }
+  const smartAccountWalletClient = await getSmartAccountWalletClient(smartAccountParams);
+  if (!smartAccountWalletClient.account) {
+    throw new Error('Smart account wallet client not found');
+  }
+  console.log('smartAccountWalletClient', smartAccountWalletClient);
+  console.log('address', smartAccountWalletClient.account.address);
+  console.log('is deployed', await isSmartAccountDeployed(smartAccountWalletClient));
+  // This will prompt the user to sign a user operation to update the smart account
+  if (await smartAccountNeedsUpdate(smartAccountWalletClient, chain, rpcUrl)) {
+    console.log('updating smart account');
+    await updateLegacySmartAccount(smartAccountWalletClient, chain, rpcUrl);
+    smartAccountParams.address = smartAccountWalletClient.account.address;
+    // Create the client again to ensure we have the 7579 config now
+    return getSmartAccountWalletClient(smartAccountParams);
+  }
+  if (!(await isSmartAccountDeployed(smartAccountWalletClient))) {
+    // TODO: remove this once we manage to get counterfactual signatures working
+    console.log('sending dummy userOp to deploy smart account');
+    if (!walletClient.account) {
+      throw new Error('Wallet client account not found');
+    }
+    const tx = await smartAccountWalletClient.sendUserOperation({
+      calls: [{ to: walletClient.account.address, data: '0x' }],
+      account: smartAccountWalletClient.account,
+    });
+
+    console.log('tx', tx);
+    const receipt = await smartAccountWalletClient.waitForUserOperationReceipt({ hash: tx });
+    console.log('receipt', receipt);
+  }
+  return smartAccountWalletClient;
+};
+
+export async function login({
+  walletClient,
+  signer,
+  syncServerUri,
+  storage,
+  identityToken,
+  rpcUrl,
+  chain,
+}: {
+  walletClient: WalletClient;
+  signer: Signer;
+  syncServerUri: string;
+  storage: Storage;
+  identityToken: string;
+  rpcUrl: string;
+  chain: Chain;
+}) {
+  let smartAccountWalletClient: SmartAccountClient;
+  try {
+    smartAccountWalletClient = await getAndDeploySmartAccount(walletClient, rpcUrl, chain, storage);
+  } catch (error) {
+    wipeAccountAddress(storage);
+    smartAccountWalletClient = await getAndDeploySmartAccount(walletClient, rpcUrl, chain, storage);
+  }
+  if (!smartAccountWalletClient.account) {
+    throw new Error('Smart account wallet client account not found');
+  }
+  const accountAddress = smartAccountWalletClient.account.address;
   // const keys = loadKeys(storage, accountAddress);
   let authData: {
     accountAddress: Address;
@@ -101,7 +181,15 @@ export async function login(
   };
   const exists = await identityExists(accountAddress, syncServerUri);
   if (!exists) {
-    authData = await signup(signer, accountAddress, syncServerUri, storage, identityToken);
+    authData = await signup(
+      signer,
+      walletClient,
+      smartAccountWalletClient,
+      accountAddress,
+      syncServerUri,
+      storage,
+      identityToken,
+    );
   } else {
     authData = await restoreKeys(signer, accountAddress, syncServerUri, storage, identityToken);
   }

package/src/connect/parse-callback-params.ts

@@ -52,13 +52,16 @@ export const parseCallbackParams = ({
     return Effect.succeed({
       appIdentityAddress: data.appIdentityAddress,
       appIdentityAddressPrivateKey: data.appIdentityAddressPrivateKey,
+      accountAddress: data.accountAddress,
+      permissionId: data.permissionId,
       signaturePublicKey: data.signaturePublicKey,
       signaturePrivateKey: data.signaturePrivateKey,
       encryptionPublicKey: data.encryptionPublicKey,
       encryptionPrivateKey: data.encryptionPrivateKey,
       sessionToken: data.sessionToken,
       sessionTokenExpires: new Date(data.sessionTokenExpires),
-      spaces: data.spaces,
+      privateSpaces: data.privateSpaces,
+      publicSpaces: data.publicSpaces,
     });
   } catch (error) {
     console.error(error);