Merge pull request #229 from getwax/wax-215-add-compression

Add compression to bundler

packages/demos/inpage/demo/config/ConfigType.ts

@@ -7,6 +7,11 @@ type ConfigType = {
   addFundsEthAmount?: string;
   deployerSeedPhrase: string;
   requirePermission?: boolean;
+  externalContracts?: {
+    entryPoint: string;
+    blsSignatureAggregator: string;
+    addressRegistry: string;
+  };
 };
 
 export default ConfigType;

packages/demos/inpage/demo/config/config.template.ts

@@ -15,11 +15,24 @@ const config: ConfigType = {
   rpcUrl: 'http://127.0.0.1:8545',
   deployerSeedPhrase:
     'test test test test test test test test test test test junk',
+
   // Uncomment this with the url of a bundler to enable using an external
   // bundler (sometimes this is the same as rpcUrl). Otherwise, a bundler will
   // be simulated inside the library.
   // bundlerRpcUrl: '',
+
   requirePermission: false,
+
+  // These contracts will be deployed deterministically by default. However,
+  // if you need to interop with a specific existing deployment, you'll need
+  // to specify the contracts here:
+  // externalContracts: {
+  //   entryPoint: '0x...',
+  //   blsSignatureAggregator: '0x...',
+  //   addressRegistry: '0x...',
+  // }
+  // (Other contracts will still be deterministically deployed, but they
+  // shouldn't be required for interop purposes.)
 };
 
 export default config;

packages/demos/inpage/demo/main.tsx

@@ -13,6 +13,7 @@ WaxInPage.addStylesheet();
 const waxInPage = new WaxInPage({
   rpcUrl: config.rpcUrl,
   bundlerRpcUrl: config.bundlerRpcUrl,
+  externalContracts: config.externalContracts,
 });
 
 waxInPage.attachGlobals();

packages/demos/inpage/scripts/dev.ts

@@ -1,12 +1,34 @@
 #!/usr/bin/env tsx
 
+/* eslint-disable no-console */
+
 import concurrently from 'concurrently';
 import config from '../demo/config/config.ts';
 
 const tasks = ['vite'];
 
+let externalNode: boolean;
+
 if (config.rpcUrl === 'http://127.0.0.1:8545') {
-  tasks.push('yarn --cwd hardhat hardhat node');
+  try {
+    await fetch(config.rpcUrl);
+    externalNode = true;
+  } catch (e) {
+    if ((e as { code: string }).code !== 'ECONNREFUSED') {
+      throw e;
+    }
+
+    externalNode = false;
+    tasks.push('yarn --cwd hardhat hardhat node');
+  }
+} else {
+  externalNode = true;
+}
+
+if (externalNode) {
+  console.log(`Relying on external node: ${config.rpcUrl}`);
+} else {
+  console.log('Starting dev node');
 }
 
 await concurrently(tasks, { killOthers: 'failure' }).result;

packages/demos/inpage/src/Button.tsx

@@ -130,6 +130,10 @@ const Button = ({
         return;
       }
 
+      if ('key' in e && e.key !== 'Enter' && e.key !== ' ') {
+        return;
+      }
+
       runAsync(async () => {
         try {
           setLoading(true);

packages/demos/inpage/src/EthereumApi.tsx

@@ -13,12 +13,14 @@ import { roundUpPseudoFloat } from './helpers/encodeUtils';
 
 // We need a UserOperation in order to estimate the gas fields of a
 // UserOperation, so we use these values as placeholders.
-const temporaryEstimationGas = '0x012345';
+const temporaryEstimationGas = '0x01234567';
 const temporarySignature = [
   '0x',
   '123456fe2807660c417ca1a38760342fa70135fcab89a8c7c879a77da8ce7a0b5a3805735e',
   '95170906b11c6f30dcc74e463e1e6990c68a3998a7271b728b123456',
 ].join('');
+const verificationGasLimitBuffer = 2000n;
+const preVerificationGasBuffer = 1000n;
 
 type StrictUserOperation = {
   sender: string;
@@ -183,9 +185,15 @@ export default class EthereumApi {
 
     return {
       ...userOp,
+      callGasLimit: roundUpPseudoFloat(userOp.callGasLimit),
+      verificationGasLimit: `0x${roundUpPseudoFloat(
+        BigInt(userOp.verificationGasLimit),
+      ).toString(16)}`,
+      preVerificationGas: `0x${roundUpPseudoFloat(
+        BigInt(userOp.preVerificationGas),
+      ).toString(16)}`,
       maxFeePerGas: roundUpPseudoFloat(userOp.maxFeePerGas),
       maxPriorityFeePerGas: roundUpPseudoFloat(userOp.maxPriorityFeePerGas),
-      callGasLimit: roundUpPseudoFloat(userOp.callGasLimit),
     };
   }
 
@@ -342,7 +350,7 @@ export default class EthereumApi {
         callData,
         callGasLimit: actions.map((a) => BigInt(a.gas)).reduce((a, b) => a + b),
         verificationGasLimit: temporaryEstimationGas,
-        preVerificationGas: temporaryEstimationGas,
+        preVerificationGas: '0x0',
         maxFeePerGas,
         maxPriorityFeePerGas,
         paymasterAndData: '0x',
@@ -360,8 +368,14 @@ export default class EthereumApi {
         params: [userOp, await contracts.entryPoint.getAddress()],
       });
 
-      userOp.verificationGasLimit = verificationGasLimit;
-      userOp.preVerificationGas = preVerificationGas;
+      userOp.verificationGasLimit = `0x${(
+        BigInt(verificationGasLimit) + verificationGasLimitBuffer
+      ).toString(16)}`;
+      userOp.preVerificationGas = `0x${(
+        BigInt(preVerificationGas) + preVerificationGasBuffer
+      ).toString(16)}`;
+
+      userOp = this.#maybeRoundUpPseudoFloats(userOp);
 
       userOpHash = await this.#calculateUserOpHash(userOp);
 

packages/demos/inpage/src/JsonRpcError.ts

@@ -1,7 +1,7 @@
 import z from 'zod';
 
 class JsonRpcError extends Error {
-  code: number;
+  code: number | string;
   data: unknown;
 
   constructor({ code, data, message }: RawJsonRpcError) {
@@ -17,7 +17,7 @@ class JsonRpcError extends Error {
 }
 
 const RawJsonRpcError = z.object({
-  code: z.number().int(),
+  code: z.union([z.number().int(), z.string()]),
   data: z.unknown(),
   message: z.string(),
 });

packages/demos/inpage/src/WaxInPage.tsx

@@ -50,6 +50,7 @@ import measureCalldataGas from './measureCalldataGas';
 import DeterministicDeployer, {
   DeterministicDeploymentViewer,
 } from '../lib-ts/deterministic-deployer/DeterministicDeployer';
+import ConfigType from '../demo/config/ConfigType';
 
 type Config = {
   logRequests?: boolean;
@@ -58,6 +59,7 @@ type Config = {
   deployContractsIfNeeded: boolean;
   ethersPollingInterval?: number;
   useTopLevelCompression?: boolean;
+  externalContracts?: ConfigType['externalContracts'];
 };
 
 const defaultConfig: Config = {
@@ -71,6 +73,7 @@ let ethersDefaultPollingInterval = 4000;
 type ConstructorOptions = {
   rpcUrl: string;
   bundlerRpcUrl?: string;
+  externalContracts?: ConfigType['externalContracts'];
   storage?: WaxStorage;
 };
 
@@ -103,6 +106,7 @@ export default class WaxInPage {
   constructor({
     rpcUrl,
     bundlerRpcUrl,
+    externalContracts,
     storage = makeLocalWaxStorage(),
   }: ConstructorOptions) {
     let bundler: IBundler;
@@ -113,6 +117,8 @@ export default class WaxInPage {
       bundler = new NetworkBundler(bundlerRpcUrl);
     }
 
+    this.#config.externalContracts =
+      externalContracts ?? this.#config.externalContracts;
     this.ethereum = new EthereumApi(rpcUrl, this, bundler);
     this.storage = storage;
     this.ethersProvider = new ethers.BrowserProvider(this.ethereum);
@@ -194,15 +200,48 @@ export default class WaxInPage {
       chainId,
     );
 
-    const assumedEntryPoint = viewer.connectAssume(EntryPoint__factory, []);
-
-    const assumedAddressRegistry = viewer.connectAssume(
-      AddressRegistry__factory,
-      [],
-    );
+    const wallet = await this.requestAdminAccount('deploy-contracts');
 
     const assumedBlsOpen = viewer.connectAssume(BLSOpen__factory, []);
 
+    let assumedEntryPoint: EntryPoint;
+    let assumedAddressRegistry: AddressRegistry;
+    let assumedBlsSignatureAggregator: BLSSignatureAggregator;
+
+    if (this.#config.externalContracts) {
+      assumedEntryPoint = EntryPoint__factory.connect(
+        this.#config.externalContracts.entryPoint,
+        wallet,
+      );
+
+      assumedBlsSignatureAggregator = BLSSignatureAggregator__factory.connect(
+        this.#config.externalContracts.blsSignatureAggregator,
+        wallet,
+      );
+
+      assumedAddressRegistry = AddressRegistry__factory.connect(
+        this.#config.externalContracts.addressRegistry,
+        wallet,
+      );
+    } else {
+      assumedEntryPoint = viewer.connectAssume(EntryPoint__factory, []);
+
+      assumedAddressRegistry = viewer.connectAssume(
+        AddressRegistry__factory,
+        [],
+      );
+
+      assumedBlsSignatureAggregator = viewer.connectAssume(
+        DeterministicDeployer.link(BLSSignatureAggregator__factory, [
+          {
+            'account-abstraction/contracts/samples/bls/lib/BLSOpen.sol:BLSOpen':
+              await assumedBlsOpen.getAddress(),
+          },
+        ]),
+        [],
+      );
+    }
+
     const contracts: Contracts = {
       greeter: viewer.connectAssume(Greeter__factory, ['']).connect(runner),
       entryPoint: assumedEntryPoint,
@@ -226,15 +265,7 @@ export default class WaxInPage {
         [],
       ),
       testToken: viewer.connectAssume(ERC20Mock__factory, []),
-      blsSignatureAggregator: viewer.connectAssume(
-        DeterministicDeployer.link(BLSSignatureAggregator__factory, [
-          {
-            'account-abstraction/contracts/samples/bls/lib/BLSOpen.sol:BLSOpen':
-              await assumedBlsOpen.getAddress(),
-          },
-        ]),
-        [],
-      ),
+      blsSignatureAggregator: assumedBlsSignatureAggregator,
     };
 
     if (this.#contractsDeployed) {
@@ -250,18 +281,48 @@ export default class WaxInPage {
       throw new Error('Contracts not deployed');
     }
 
-    const wallet = await this.requestAdminAccount('deploy-contracts');
-
     const factory = await DeterministicDeployer.init(wallet);
 
-    const entryPoint = await factory.connectOrDeploy(EntryPoint__factory, []);
+    const blsOpen = await factory.connectOrDeploy(BLSOpen__factory, []);
 
-    const addressRegistry = await factory.connectOrDeploy(
-      AddressRegistry__factory,
-      [],
-    );
+    let entryPoint: EntryPoint;
+    let blsSignatureAggregator: BLSSignatureAggregator;
+    let addressRegistry: AddressRegistry;
+
+    if (this.#config.externalContracts) {
+      entryPoint = assumedEntryPoint;
+      blsSignatureAggregator = assumedBlsSignatureAggregator;
+      addressRegistry = assumedAddressRegistry;
+
+      await Promise.all(
+        [entryPoint, blsSignatureAggregator, addressRegistry].map(
+          async (contract) => {
+            if (!(await this.#checkDeployed(await contract.getAddress()))) {
+              throw new Error(
+                `External contract not deployed: ${await contract.getAddress()}`,
+              );
+            }
+          },
+        ),
+      );
+    } else {
+      entryPoint = await factory.connectOrDeploy(EntryPoint__factory, []);
 
-    const blsOpen = await factory.connectOrDeploy(BLSOpen__factory, []);
+      blsSignatureAggregator = await factory.connectOrDeploy(
+        DeterministicDeployer.link(BLSSignatureAggregator__factory, [
+          {
+            'account-abstraction/contracts/samples/bls/lib/BLSOpen.sol:BLSOpen':
+              await blsOpen.getAddress(),
+          },
+        ]),
+        [],
+      );
+
+      addressRegistry = await factory.connectOrDeploy(
+        AddressRegistry__factory,
+        [],
+      );
+    }
 
     const deployments: {
       [C in keyof Contracts]: () => Promise<Contracts[C]>;
@@ -285,16 +346,7 @@ export default class WaxInPage {
       safeECDSARecoveryPlugin: () =>
         factory.connectOrDeploy(SafeECDSARecoveryPlugin__factory, []),
       testToken: () => factory.connectOrDeploy(ERC20Mock__factory, []),
-      blsSignatureAggregator: async () =>
-        factory.connectOrDeploy(
-          DeterministicDeployer.link(BLSSignatureAggregator__factory, [
-            {
-              'account-abstraction/contracts/samples/bls/lib/BLSOpen.sol:BLSOpen':
-                await blsOpen.getAddress(),
-            },
-          ]),
-          [],
-        ),
+      blsSignatureAggregator: () => Promise.resolve(blsSignatureAggregator),
     };
 
     for (const deployment of Object.values(deployments)) {
@@ -306,18 +358,19 @@ export default class WaxInPage {
 
   async #checkDeployments(contracts: Contracts): Promise<boolean> {
     const deployFlags = await Promise.all(
-      Object.values(contracts).map(async (contract) => {
-        const existingCode = await this.ethersProvider.getCode(
-          contract.getAddress(),
-        );
-
-        return existingCode !== '0x';
-      }),
+      Object.values(contracts).map(
+        async (contract) =>
+          await this.#checkDeployed(await contract.getAddress()),
+      ),
     );
 
     return deployFlags.every((flag) => flag);
   }
 
+  async #checkDeployed(address: string): Promise<boolean> {
+    return (await this.ethersProvider.getCode(address)) !== '0x';
+  }
+
   async requestAdminAccount(purpose: AdminPurpose): Promise<ethers.Wallet> {
     if (this.#adminAccount) {
       return this.#adminAccount;