Feat/update tests

.github/workflows/build-lint-test.yml

@@ -89,6 +89,7 @@ jobs:
           node-version: ${{ matrix.node-version }}
           cache: 'yarn'
       - run: yarn --immutable --immutable-cache
+      - run: yarn build
       - run: yarn test
       - name: Require clean working directory
         shell: bash

.gitignore

@@ -66,7 +66,7 @@ node_modules/
 .yarn-integrity
 
 # dotenv environment variables file
-.env
+packages/snap/.env
 .env.test
 
 # Stores VSCode versions used for testing VSCode extensions
@@ -80,4 +80,8 @@ node_modules/
 !.yarn/plugins
 !.yarn/releases
 !.yarn/sdks
-!.yarn/versions
+!.yarn/versions
+
+# IntelliJ
+.idea/
+/.idea/

.prettierignore

@@ -0,0 +1,3 @@
+packages/snap/artifacts
+packages/snap/cache
+packages/snap/coverage

README.md

@@ -1,4 +1,4 @@
-# Simple Keyring Snap
+# Simple Account Abstraction Snap
 
 This repository contains a simple example of a keyring snap.
 

packages/site/package.json

@@ -29,8 +29,8 @@
   "dependencies": {
     "@emotion/react": "^11.11.1",
     "@emotion/styled": "^11.11.0",
-    "@metamask/keyring-api": "^1.0.0-rc.1",
-    "@metamask/providers": "^13.0.0",
+    "@metamask/keyring-api": "^2.0.0",
+    "@metamask/providers": "^14.0.2",
     "@mui/icons-material": "^5.14.0",
     "@mui/material": "^5.14.0",
     "@types/react-helmet": "^6.1.6",

packages/site/src/components/Header.tsx

@@ -108,7 +108,7 @@ export const Header = () => {
   return (
     <HeaderWrapper>
       <LogoWrapper>
-        <Title>🔑 Snap Simple Keyring</Title>
+        <Title>🔑 Snap Account Abstraction Keyring</Title>
       </LogoWrapper>
       <RightContainer>
         <Version />

packages/site/src/pages/index.tsx

@@ -1,15 +1,9 @@
 import type { KeyringAccount, KeyringRequest } from '@metamask/keyring-api';
 import { KeyringSnapRpcClient } from '@metamask/keyring-api';
 import Grid from '@mui/material/Grid';
-import React, { useCallback, useContext, useEffect, useState } from 'react';
+import React, { useContext, useEffect, useState } from 'react';
 
-import {
-  Accordion,
-  AccountList,
-  Card,
-  ConnectButton,
-  Toggle,
-} from '../components';
+import { Accordion, AccountList, Card, ConnectButton } from '../components';
 import {
   CardContainer,
   Container,
@@ -18,15 +12,10 @@ import {
   StyledBox,
 } from '../components/styledComponents';
 import { defaultSnapOrigin } from '../config';
-import { MetaMaskContext, MetamaskActions } from '../hooks';
+import { MetamaskActions, MetaMaskContext } from '../hooks';
 import { InputType } from '../types';
 import type { KeyringState } from '../utils';
-import {
-  connectSnap,
-  getSnap,
-  isSynchronousMode,
-  toggleSynchronousApprovals,
-} from '../utils';
+import { connectSnap, getSnap, isSynchronousMode } from '../utils';
 
 const snapId = defaultSnapOrigin;
 
@@ -47,11 +36,11 @@ const Index = () => {
   // a component but for this case it should be ok since this is an
   // internal development and testing tool.
   const [privateKey, setPrivateKey] = useState<string | null>();
+  const [salt, setSalt] = useState<string | null>();
   const [accountId, setAccountId] = useState<string | null>();
   const [accountObject, setAccountObject] = useState<string | null>();
   const [requestId, setRequestId] = useState<string | null>(null);
-  // const [accountPayload, setAccountPayload] =
-  //   useState<Pick<KeyringAccount, 'name' | 'options'>>();
+
   const client = new KeyringSnapRpcClient(snapId, window.ethereum);
 
   useEffect(() => {
@@ -86,14 +75,9 @@ const Index = () => {
   };
 
   const createAccount = async () => {
-    const newAccount = await client.createAccount();
-    await syncAccounts();
-    return newAccount;
-  };
-
-  const importAccount = async () => {
     const newAccount = await client.createAccount({
       privateKey: privateKey as string,
+      salt: salt as string,
     });
     await syncAccounts();
     return newAccount;
@@ -128,45 +112,44 @@ const Index = () => {
     }
   };
 
-  const handleUseSyncToggle = useCallback(async () => {
-    console.log('Toggling synchronous approval');
-    await toggleSynchronousApprovals();
-    setSnapState({
-      ...snapState,
-      useSynchronousApprovals: !snapState.useSynchronousApprovals,
-    });
-  }, [snapState]);
+  // Note: not using this for now
+  // const handleUseSyncToggle = useCallback(async () => {
+  //   console.log('Toggling synchronous approval');
+  //   await toggleSynchronousApprovals();
+  //   setSnapState({
+  //     ...snapState,
+  //     useSynchronousApprovals: !snapState.useSynchronousApprovals,
+  //   });
+  // }, [snapState]);
 
   const accountManagementMethods = [
     {
       name: 'Create account',
-      description: 'Create a new account',
-      inputs: [],
-      action: {
-        callback: async () => await createAccount(),
-        label: 'Create Account',
-      },
-      successMessage: 'Account created',
-    },
-    {
-      name: 'Import account',
-      description: 'Import an account using a private key',
+      description: 'Create a 4337 account using an admin private key',
       inputs: [
         {
-          id: 'import-account-private-key',
+          id: 'create-account-private-key',
           title: 'Private key',
           value: privateKey,
           type: InputType.TextField,
           placeholder:
             'E.g. 0000000000000000000000000000000000000000000000000000000000000000',
           onChange: (event: any) => setPrivateKey(event.currentTarget.value),
         },
+        {
+          id: 'create-account-salt',
+          title: 'Salt (optional)',
+          value: salt,
+          type: InputType.TextField,
+          placeholder: 'E.g. 0x123',
+          onChange: (event: any) => setSalt(event.currentTarget.value),
+        },
       ],
       action: {
-        callback: async () => await importAccount(),
-        label: 'Import Account',
+        callback: async () => await createAccount(),
+        label: 'Create Account',
       },
-      successMessage: 'Account imported',
+      successMessage: 'Smart Contract Account Created',
     },
     {
       name: 'Get account',
@@ -352,14 +335,15 @@ const Index = () => {
       <StyledBox sx={{ flexGrow: 1 }}>
         <Grid container spacing={4} columns={[1, 2, 3]}>
           <Grid item xs={8} sm={4} md={2}>
-            <DividerTitle>Options</DividerTitle>
-            <Toggle
-              title="Use Synchronous Approval"
-              defaultChecked={snapState.useSynchronousApprovals}
-              onToggle={handleUseSyncToggle}
-              enabled={Boolean(state.installedSnap)}
-            />
-            <Divider>&nbsp;</Divider>
+            {/* Not using this for now*/}
+            {/* <DividerTitle>Options</DividerTitle>*/}
+            {/* <Toggle*/}
+            {/*  title="Use Synchronous Approval"*/}
+            {/*  defaultChecked={snapState.useSynchronousApprovals}*/}
+            {/*  onToggle={handleUseSyncToggle}*/}
+            {/*  enabled={Boolean(state.installedSnap)}*/}
+            {/*/ >*/}
+            {/* <Divider>&nbsp;</Divider>*/}
             <DividerTitle>Methods</DividerTitle>
             <Accordion items={accountManagementMethods} />
             <Divider />

packages/site/src/utils/snap.ts

@@ -81,14 +81,16 @@ export const toggleSynchronousApprovals = async () => {
   });
 };
 
+// Note: not used in the example
 export const isSynchronousMode = async (): Promise<boolean> => {
-  return (await window.ethereum.request({
-    method: 'wallet_invokeSnap',
-    params: {
-      snapId: defaultSnapOrigin,
-      request: { method: 'snap.internal.isSynchronousMode' },
-    },
-  })) as boolean;
+  // return (await window.ethereum.request({
+  //   method: 'wallet_invokeSnap',
+  //   params: {
+  //     snapId: defaultSnapOrigin,
+  //     request: { method: 'snap.internal.isSynchronousMode' },
+  //   },
+  // })) as boolean;
+  return true;
 };
 
 export const isLocalSnap = (snapId: string) => snapId.startsWith('local:');

packages/snap/.env.sample

@@ -1,2 +1,4 @@
 INFURA_PROJECT_ID=YOUR_INFURA_PROJECT_ID
-MNEMONIC=YOUR_MNEMONIC
+MNEMONIC=YOUR_MNEMONIC
+BUNDLER_URL=BUNDLER_URL
+VERIFYING_PAYMASTER_ADDRESS=PAYMASTER_ADDRESS

packages/snap/.eslintrc.js

@@ -11,5 +11,12 @@ module.exports = {
     },
   ],
 
-  ignorePatterns: ['!.eslintrc.js', 'dist/'],
+  ignorePatterns: [
+    '!.eslintrc.js',
+    'dist/',
+    'contracts/',
+    'coverage/',
+    'cache/',
+    'artifacts/',
+  ],
 };

packages/snap/README.md

@@ -15,3 +15,9 @@ can customize the wallet experience.
 1. `yarn install` to install the dependencies
 2. `yarn compile` to build the types for the contracts.
 3. `yarn serve` to create a local instance of the snap.
+
+# Deploying Factory Contracts
+
+Deploying the contracts will use eth from the first account of your mnemonic.
+
+1. `yarn hardhat --network <chain name specified in hardhat config> run scripts/deployFactory.ts`

packages/snap/contracts/samples/SimpleAccountFactory.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0
 pragma solidity ^0.8.12;
 
-import "@openzeppelin/contracts/utils/Create2.sol";
-import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import '@openzeppelin/contracts/utils/Create2.sol';
+import '@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol';
 
-import "./SimpleAccount.sol";
+import './SimpleAccount.sol';
 
 /**
  * A sample factory contract for SimpleAccount
@@ -13,40 +13,56 @@ import "./SimpleAccount.sol";
  * This way, the entryPoint.getSenderAddress() can be called either before or after the account is created.
  */
 contract SimpleAccountFactory {
-    SimpleAccount public immutable accountImplementation;
+  SimpleAccount public immutable accountImplementation;
 
-    constructor(IEntryPoint _entryPoint) {
-        accountImplementation = new SimpleAccount(_entryPoint);
-    }
+  constructor(IEntryPoint _entryPoint) {
+    accountImplementation = new SimpleAccount(_entryPoint);
+  }
 
-    /**
-     * create an account, and return its address.
-     * returns the address even if the account is already deployed.
-     * Note that during UserOperation execution, this method is called only if the account is not deployed.
-     * This method returns an existing account address so that entryPoint.getSenderAddress() would work even after account creation
-     */
-    function createAccount(address owner,uint256 salt) public returns (SimpleAccount ret) {
-        address addr = getAddress(owner, salt);
-        uint codeSize = addr.code.length;
-        if (codeSize > 0) {
-            return SimpleAccount(payable(addr));
-        }
-        ret = SimpleAccount(payable(new ERC1967Proxy{salt : bytes32(salt)}(
-                address(accountImplementation),
-                abi.encodeCall(SimpleAccount.initialize, (owner))
-            )));
+  /**
+   * create an account, and return its address.
+   * returns the address even if the account is already deployed.
+   * Note that during UserOperation execution, this method is called only if the account is not deployed.
+   * This method returns an existing account address so that entryPoint.getSenderAddress() would work even after account creation
+   */
+  function createAccount(
+    address owner,
+    uint256 salt
+  ) public returns (SimpleAccount ret) {
+    address addr = getAccountAddress(owner, salt);
+    uint codeSize = addr.code.length;
+    if (codeSize > 0) {
+      return SimpleAccount(payable(addr));
     }
+    ret = SimpleAccount(
+      payable(
+        new ERC1967Proxy{salt: bytes32(salt)}(
+          address(accountImplementation),
+          abi.encodeCall(SimpleAccount.initialize, (owner))
+        )
+      )
+    );
+  }
 
-    /**
-     * calculate the counterfactual address of this account as it would be returned by createAccount()
-     */
-    function getAddress(address owner,uint256 salt) public view returns (address) {
-        return Create2.computeAddress(bytes32(salt), keccak256(abi.encodePacked(
-                type(ERC1967Proxy).creationCode,
-                abi.encode(
-                    address(accountImplementation),
-                    abi.encodeCall(SimpleAccount.initialize, (owner))
-                )
-            )));
-    }
+  /**
+   * calculate the counterfactual address of this account as it would be returned by createAccount()
+   */
+  function getAccountAddress(
+    address owner,
+    uint256 salt
+  ) public view returns (address) {
+    return
+      Create2.computeAddress(
+        bytes32(salt),
+        keccak256(
+          abi.encodePacked(
+            type(ERC1967Proxy).creationCode,
+            abi.encode(
+              address(accountImplementation),
+              abi.encodeCall(SimpleAccount.initialize, (owner))
+            )
+          )
+        )
+      );
+  }
 }