still wip

Author: pcarranzav

packages/hypergraph/package.json

@@ -39,6 +39,7 @@
     "@xstate/store": "^3.5.1",
     "bs58check": "^4.0.0",
     "effect": "^3.16.3",
+    "permissionless": "^0.2.47",
     "siwe": "^3.0.0",
     "uuid": "^11.1.0",
     "viem": "^2.30.6"

packages/hypergraph/src/identity/abis.ts

@@ -0,0 +1,29 @@
+// Simplified ABI for the Safe Module Manager with the functions we need
+export const safeModuleManagerAbi = [
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'module',
+        type: 'address',
+      },
+    ],
+    name: 'enableModule',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'module',
+        type: 'address',
+      },
+    ],
+    name: 'disableModule',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+];

packages/hypergraph/src/identity/smart-account.ts

@@ -1,40 +1,46 @@
+import { bytesToHex, randomBytes } from '@noble/hashes/utils';
 import {
   OWNABLE_VALIDATOR_ADDRESS,
-  Session,
+  type Policy,
+  type Session,
   encodeSmartSessionSignature,
   encodeValidationData,
   encodeValidatorNonce,
-  getAccount,
-  getEnableSessionDetails,
   getOwnableValidator,
-  getOwnableValidatorMockSignature,
   getSmartSessionsValidator,
   getSudoPolicy,
 } from '@rhinestone/module-sdk';
-import { createSmartAccountClient } from 'permissionless';
-import { toSafeSmartAccount } from 'permissionless/accounts';
+import { type SmartAccountClient, createSmartAccountClient, encodeInstallModule } from 'permissionless';
+import { type ToSafeSmartAccountParameters, toSafeSmartAccount } from 'permissionless/accounts';
 import { erc7579Actions } from 'permissionless/actions/erc7579';
+import type { Erc7579Actions } from 'permissionless/actions/erc7579';
 import { createPimlicoClient } from 'permissionless/clients/pimlico';
-import { http, type WalletClient, createPublicClient } from 'viem';
-import { entryPoint07Address } from 'viem/account-abstraction';
+import { http, Address, type Chain, Hex, type WalletClient, createPublicClient, encodeFunctionData } from 'viem';
+import { type SmartAccount, entryPoint07Address } from 'viem/account-abstraction';
+import { safeModuleManagerAbi } from './abis.js';
 
 const DEFAULT_RPC_URL = 'https://rpc-geo-genesis-h0q2s21xx8.t.conduit.xyz';
 /**
  * We provide a fallback API key for gas sponsorship for the duration of the
  * Geo Genesis early access period. This API key is gas-limited.
  */
 const DEFAULT_API_KEY = 'pim_KqHm63txxhbCYjdDaWaHqH';
-const BUNDLER_TRANSPORT_URL_BASE = 'https://api.pimlico.io/v2/80451/rpc?apikey=';
+const BUNDLER_TRANSPORT_URL_BASE = 'https://api.pimlico.io/v2/';
 
 const SAFE_7579_MODULE_ADDRESS = '0x7579EE8307284F293B1927136486880611F20002';
+const SAFE_4337_MODULE_ADDRESS = '0x75cf11467937ce3F2f357CE24ffc3DBF8fD5c226';
 const ERC7579_LAUNCHPAD_ADDRESS = '0x7579011aB74c46090561ea277Ba79D510c6C00ff';
 
-const GEOGENESIS = {
+const SPACE_FACTORY_ADDRESS = '0x0000000000000000000000000000000000000000'; // TODO: add address
+const SPACE_FACTORY_CREATE_SPACE_SELECTOR = '0x00000000'; // TODO: add selector
+
+// TODO: add details for testnet too
+export const GEOGENESIS = {
   id: Number('80451'),
   name: 'Geo Genesis',
   nativeCurrency: {
-    name: 'Ethereum',
-    symbol: 'ETH',
+    name: 'Graph Token',
+    symbol: 'GRT',
     decimals: 18,
   },
   rpcUrls: {
@@ -47,15 +53,19 @@ const GEOGENESIS = {
   },
 };
 
+export type LegacySmartAccountClient = SmartAccountClient;
+export type HypergraphSmartAccountClient = SmartAccountClient & Erc7579Actions<SmartAccount>;
+
 export const getLegacySmartAccountWalletClient = async (
   walletClient: WalletClient,
+  chain: Chain = GEOGENESIS,
   rpcUrl: string = DEFAULT_RPC_URL,
   apiKey: string = DEFAULT_API_KEY,
-) => {
+): Promise<LegacySmartAccountClient> => {
   const transport = http(rpcUrl);
   const publicClient = createPublicClient({
     transport,
-    chain: GEOGENESIS,
+    chain,
   });
 
   const safeAccount = await toSafeSmartAccount({
@@ -69,18 +79,18 @@ export const getLegacySmartAccountWalletClient = async (
     version: '1.4.1',
   });
 
-  const bundlerTransport = http(`${BUNDLER_TRANSPORT_URL_BASE}${apiKey}`);
+  const bundlerTransport = http(`${BUNDLER_TRANSPORT_URL_BASE}${chain.id}/rpc?apikey=${apiKey}`);
   const paymasterClient = createPimlicoClient({
     transport: bundlerTransport,
-    chain: GEOGENESIS,
+    chain,
     entryPoint: {
       address: entryPoint07Address,
       version: '0.7',
     },
   });
 
   const smartAccount = createSmartAccountClient({
-    chain: GEOGENESIS,
+    chain,
     account: safeAccount,
     paymaster: paymasterClient,
     bundlerTransport,
@@ -95,58 +105,67 @@ export const getLegacySmartAccountWalletClient = async (
 
 export const get7579SmartAccountWalletClient = async (
   walletClient: WalletClient,
-  address: string | undefined,
+  address: `0x${string}` | undefined,
+  chain: Chain = GEOGENESIS,
   rpcUrl: string = DEFAULT_RPC_URL,
   apiKey: string = DEFAULT_API_KEY,
-) => {
+): Promise<HypergraphSmartAccountClient> => {
   if (!walletClient.account) {
     throw new Error('Wallet client must be an account');
   }
 
   const transport = http(rpcUrl);
   const publicClient = createPublicClient({
     transport,
-    chain: GEOGENESIS,
+    chain,
   });
 
   const ownableValidator = getOwnableValidator({
     owners: [walletClient.account.address],
     threshold: 1,
   });
+  const smartSessionsValidator = getSmartSessionsValidator({});
 
-  const safeAccount = await toSafeSmartAccount({
+  const safeAccountParams: ToSafeSmartAccountParameters<'0.7', `0x${string}`> = {
     client: publicClient,
-    address,
     owners: [walletClient],
-    version: '1.4.1',
+    version: '1.4.1' as const,
     entryPoint: {
       address: entryPoint07Address,
-      version: '0.7',
+      version: '0.7' as const,
     },
-    safe4337ModuleAddress: SAFE_7579_MODULE_ADDRESS,
-    erc7579LaunchpadAddress: ERC7579_LAUNCHPAD_ADDRESS,
+    safe4337ModuleAddress: SAFE_7579_MODULE_ADDRESS as `0x${string}`,
+    erc7579LaunchpadAddress: ERC7579_LAUNCHPAD_ADDRESS as `0x${string}`,
     attesters: [],
     attestersThreshold: 0,
     validators: [
       {
         address: ownableValidator.address,
         context: ownableValidator.initData,
       },
+      {
+        address: smartSessionsValidator.address,
+        context: smartSessionsValidator.initData,
+      },
     ],
-  });
+  };
+  if (address) {
+    safeAccountParams.address = address;
+  }
+  const safeAccount = await toSafeSmartAccount(safeAccountParams);
 
-  const bundlerTransport = http(`${BUNDLER_TRANSPORT_URL_BASE}${apiKey}`);
+  const bundlerTransport = http(`${BUNDLER_TRANSPORT_URL_BASE}${chain.id}/rpc?apikey=${apiKey}`);
   const paymasterClient = createPimlicoClient({
     transport: bundlerTransport,
-    chain: GEOGENESIS,
+    chain,
     entryPoint: {
       address: entryPoint07Address,
       version: '0.7',
     },
   });
 
   const smartAccount = createSmartAccountClient({
-    chain: GEOGENESIS,
+    chain,
     account: safeAccount,
     paymaster: paymasterClient,
     bundlerTransport,
@@ -159,14 +178,133 @@ export const get7579SmartAccountWalletClient = async (
   return smartAccount;
 };
 
-const updateLegacySmartAccount = async (smartAccount: GeoSmartAccount) => {
-  // TODO We need to enable the 7579 module and disable the 4337 module
+export const isSmartAccountDeployed = async (
+  smartAccount: LegacySmartAccountClient | HypergraphSmartAccountClient,
+): Promise<boolean> => {
+  return smartAccount.account.isDeployed();
 };
 
-const createSmartSession = async (smartAccount: GeoSmartAccount) => {
-  // TODO
-  // Check if the smart account has the smart session module enabled
-  // Enable it if needed
-  // Create a smart session
-  // Execute the userOp
+export const updateLegacySmartAccount = async (smartAccount: LegacySmartAccountClient) => {
+  const ownableValidator = getOwnableValidator({
+    owners: [smartAccount.account.address],
+    threshold: 1,
+  });
+  const smartSessionsValidator = getSmartSessionsValidator({});
+  const installOwnableValidatorTx = encodeInstallModule({
+    account: smartAccount.account,
+    modules: [
+      {
+        type: ownableValidator.type,
+        address: ownableValidator.address,
+        context: ownableValidator.initData,
+      },
+      {
+        type: smartSessionsValidator.type,
+        address: smartSessionsValidator.address,
+        context: smartSessionsValidator.initData,
+      },
+    ],
+  });
+
+  const calls = [
+    {
+      to: smartAccount.account.address,
+      data: encodeFunctionData({
+        abi: safeModuleManagerAbi,
+        functionName: 'enableModule',
+        args: [SAFE_7579_MODULE_ADDRESS as `0x${string}`],
+      }),
+      value: BigInt(0),
+    },
+    {
+      to: smartAccount.account.address,
+      data: encodeFunctionData({
+        abi: safeModuleManagerAbi,
+        functionName: 'setFallbackHandler',
+        args: [SAFE_7579_MODULE_ADDRESS as `0x${string}`],
+      }),
+      value: BigInt(0),
+    },
+    {
+      to: smartAccount.account.address,
+      data: encodeFunctionData({
+        abi: safeModuleManagerAbi,
+        functionName: 'disableModule',
+        args: [SAFE_4337_MODULE_ADDRESS as `0x${string}`],
+      }),
+      value: BigInt(0),
+    },
+    {
+      to: installOwnableValidatorTx[0].to,
+      data: installOwnableValidatorTx[0].data,
+      value: installOwnableValidatorTx[0].value,
+    },
+    {
+      to: installOwnableValidatorTx[1].to,
+      data: installOwnableValidatorTx[1].data,
+      value: installOwnableValidatorTx[1].value,
+    },
+  ];
+
+  const tx = await smartAccount.sendTransaction({
+    calls,
+  });
+  const receipt = await smartAccount.waitForTransactionReceipt({
+    hash: tx.hash,
+  });
+  if (receipt.status !== 'success') {
+    throw new Error('Transaction to update legacy smart account failed');
+  }
+  return receipt;
+};
+
+type Action = {
+  actionTarget: Address;
+  actionTargetSelector: Hex;
+  actionPolicies: { policy: Address; address: Address; initData: Hex }[];
+};
+
+export const createSmartSession = async (
+  smartAccount: HypergraphSmartAccountClient,
+  sessionKeyAddress: `0x${string}`,
+  {
+    allowCreateSpace = false,
+    spaceAddresses = [],
+  }: {
+    allowCreateSpace?: boolean;
+    spaceAddresses?: `0x${string}`[];
+  } = {},
+) => {
+  const actions: Action[] = [];
+  for (const spaceAddress of spaceAddresses) {
+    actions.push({
+      actionTarget: spaceAddress,
+      actionTargetSelector: '0x00000000' as Hex,
+      actionPolicies: [getSudoPolicy()],
+    });
+  }
+  if (allowCreateSpace) {
+    actions.push({
+      actionTarget: SPACE_FACTORY_ADDRESS,
+      actionTargetSelector: SPACE_FACTORY_CREATE_SPACE_SELECTOR as Hex,
+      actionPolicies: [getSudoPolicy()],
+    });
+  }
+
+  const session: Session = {
+    sessionValidator: OWNABLE_VALIDATOR_ADDRESS,
+    sessionValidatorInitData: encodeValidationData({
+      threshold: 1,
+      owners: [sessionKeyAddress],
+    }),
+    salt: bytesToHex(randomBytes(32)),
+    userOpPolicies: [getSudoPolicy()],
+    erc7739Policies: {
+      allowedERC7739Content: [],
+      erc1271Policies: [],
+    },
+    actions,
+    chainId: BigInt(smartAccount.chain.id),
+    permitERC4337Paymaster: true,
+  };
 };