Feature/aa zero transactions mvp (#468)

* Implement basic Paymaster Transaction flow
* Enable flow under FEATURE_PAYMASTER flag

Author: everdimension

.env.example

@@ -7,4 +7,5 @@ TEST_WALLET_ADDRESS=
 PROXY_URL=https://proxy.zerion.io/
 FEATURE_FOOTER_BUG_BUTTON=on
 FEATURE_SEND_FORM=
+FEATURE_PAYMASTER=
 MIXPANEL_TOKEN_PUBLIC=

.github/workflows/pr.yml

@@ -9,6 +9,10 @@ on:
         default: ''
         description: 'Backend env for special features'
         required: false
+      FEATURE_PAYMASTER:
+        default: 'off'
+        description: 'Feature flag for paymaster transactions ("on" | "off")'
+        required: false
       DEFI_SDK_API_URL:
         default: wss://api-v4.zerion.io/
         description: 'Zerion API'
@@ -53,6 +57,7 @@ jobs:
           DEFI_SDK_API_URL: ${{ github.event.inputs.DEFI_SDK_API_URL || 'wss://api-v4.zerion.io/' }}
           ZERION_API_URL: ${{ github.event.inputs.ZERION_API_URL || 'https://zpi.zerion.io/' }}
           BACKEND_ENV: ${{ github.event.inputs.BACKEND_ENV || '' }}
+          FEATURE_PAYMASTER: ${{ github.event.inputs.FEATURE_PAYMASTER || '' }}
           PROXY_URL: ${{ github.event.inputs.PROXY_URL || 'https://proxy.zerion.io/' }}
           DEFI_SDK_TRANSACTIONS_API_URL: ${{ github.event.inputs.DEFI_SDK_TRANSACTIONS_API_URL || 'https://transactions.zerion.io' }}
           DEFI_SDK_API_TOKEN: Zerion.0JOY6zZTTw6yl5Cvz9sdmXc7d5AhzVMG

package-lock.json

@@ -91,6 +91,7 @@
   },
   "dependencies": {
     "@download/blockies": "^1.0.3",
+    "@ethersproject/abstract-provider": "^5.7.0",
     "@react-spring/web": "^9.7.3",
     "@store-unit/react": "^1.0.4",
     "@tanstack/react-query": "^4.35.3",
@@ -127,6 +128,7 @@
     "rlp": "^3.0.0",
     "store-unit": "^1.0.3",
     "uuid": "^9.0.0",
-    "webextension-polyfill": "^0.10.0"
+    "webextension-polyfill": "^0.10.0",
+    "zksync-ethers": "^5.7.2"
   }
 }

package.json

@@ -1,5 +1,10 @@
-import type { UnsignedTransaction } from 'ethers';
+import type { BigNumberish, UnsignedTransaction } from 'ethers';
 import { ethers } from 'ethers';
+import {
+  EIP712Signer,
+  utils as zkSyncUtils,
+  Provider as ZksProvider,
+} from 'zksync-ethers';
 import type { Emitter } from 'nanoevents';
 import { createNanoEvents } from 'nanoevents';
 import { Store } from 'store-unit';
@@ -28,7 +33,10 @@ import {
   INTERNAL_ORIGIN_SYMBOL,
 } from 'src/background/constants';
 import { networksStore } from 'src/modules/networks/networks-store.background';
-import type { IncomingTransaction } from 'src/modules/ethereum/types/IncomingTransaction';
+import type {
+  IncomingTransactionAA,
+  IncomingTransactionWithChainId,
+} from 'src/modules/ethereum/types/IncomingTransaction';
 import { prepareTransaction } from 'src/modules/ethereum/transactions/prepareTransaction';
 import type { Chain } from 'src/modules/networks/Chain';
 import { createChain } from 'src/modules/networks/Chain';
@@ -69,6 +77,8 @@ import { backgroundGetBestKnownTransactionCount } from 'src/modules/ethereum/tra
 import { toCustomNetworkId } from 'src/modules/ethereum/chains/helpers';
 import { normalizeTransactionChainId } from 'src/modules/ethereum/transactions/normalizeTransactionChainId';
 import type { ChainId } from 'src/modules/ethereum/transactions/ChainId';
+import { FEATURE_PAYMASTER_ENABLED } from 'src/env/config';
+import { createTypedData } from 'src/modules/ethereum/account-abstraction/createTypedData';
 import type { DaylightEventParams, ScreenViewParams } from '../events';
 import { emitter } from '../events';
 import type { Credentials, SessionCredentials } from '../account/Credentials';
@@ -92,7 +102,11 @@ import {
   ReadonlyAccountContainer,
 } from './model/AccountContainer';
 
-async function prepareNonce<T extends { nonce?: number; from?: string }>(
+if (FEATURE_PAYMASTER_ENABLED) {
+  Object.assign(globalThis, { EIP712Signer, zkSyncUtils });
+}
+
+async function prepareNonce<T extends { nonce?: BigNumberish; from?: string }>(
   transaction: T,
   networks: Networks,
   chain: string
@@ -899,10 +913,26 @@ export class Wallet {
     this.emitter.emit('chainChanged', chain, origin);
   }
 
+  /** A helper for interpretation in UI */
+  async uiGetEip712Transaction({
+    params: { transaction },
+    context,
+  }: WalletMethodParams<{ transaction: IncomingTransactionWithChainId }>) {
+    this.verifyInternalOrigin(context);
+
+    const prepared = prepareTransaction(transaction);
+    const typedData = createTypedData(prepared);
+    return typedData;
+  }
+
   private async getProvider(chainId: ChainId) {
     const networks = await networksStore.loadNetworksWithChainId(chainId);
     const nodeUrl = networks.getRpcUrlInternal(networks.getChainById(chainId));
-    return new ethers.providers.JsonRpcProvider(nodeUrl);
+    if (FEATURE_PAYMASTER_ENABLED) {
+      return new ZksProvider(nodeUrl);
+    } else {
+      return new ethers.providers.JsonRpcProvider(nodeUrl);
+    }
   }
 
   private async getSigner(chainId: ChainId) {
@@ -927,7 +957,7 @@ export class Wallet {
     context,
     ...transactionContextParams
   }: {
-    transaction: IncomingTransaction;
+    transaction: IncomingTransactionAA;
     context: Partial<ChannelContext> | undefined;
   } & TransactionContextParams): Promise<ethers.providers.TransactionResponse> {
     this.verifyInternalOrigin(context);
@@ -968,31 +998,66 @@ export class Wallet {
     invariant(chainId, 'Must resolve chainId first');
 
     const networks = await networksStore.loadNetworksWithChainId(chainId);
-    const signer = await this.getSigner(chainId);
     const prepared = prepareTransaction(incomingTransaction);
     const txWithFee = await prepareGasAndNetworkFee(prepared, networks);
     const transaction = await prepareNonce(txWithFee, networks, chain);
 
-    try {
-      const transactionResponse = await signer.sendTransaction({
-        ...transaction,
-        type: transaction.type || undefined, // to exclude null
-      });
-      const safeTx = removeSignature(transactionResponse);
-      emitter.emit('transactionSent', {
-        transaction: safeTx,
-        ...transactionContextParams,
-      });
-      return safeTx;
-    } catch (error) {
-      throw getEthersError(error);
+    const paymasterEligible =
+      FEATURE_PAYMASTER_ENABLED &&
+      Boolean(transaction.customData?.paymasterParams);
+
+    if (paymasterEligible) {
+      console.log('paymasterEligible', { transaction });
+      try {
+        const { chainId } = transaction;
+        invariant(chainId, 'ChainId missing from TransactionRequest');
+        const typedData = createTypedData(transaction);
+        console.log('will sign typedData:', { typedData });
+        const signature = await this.signTypedData_v4({
+          context,
+          params: { typedData, ...transactionContextParams },
+        });
+        console.log('will serialize transaction + signature', {
+          transaction,
+          signature,
+        });
+        const rawTransaction = zkSyncUtils.serialize({
+          ...transaction,
+          customData: { ...transaction.customData, customSignature: signature },
+        });
+
+        console.log({ rawTransaction });
+        return await this.sendSignedTransaction({
+          context,
+          params: { serialized: rawTransaction, ...transactionContextParams },
+        });
+      } catch (error) {
+        console.log('paymaster tx error', error);
+        throw getEthersError(error);
+      }
+    } else {
+      try {
+        const signer = await this.getSigner(chainId);
+        const transactionResponse = await signer.sendTransaction({
+          ...transaction,
+          type: transaction.type || undefined, // to exclude null
+        });
+        const safeTx = removeSignature(transactionResponse);
+        emitter.emit('transactionSent', {
+          transaction: safeTx,
+          ...transactionContextParams,
+        });
+        return safeTx;
+      } catch (error) {
+        throw getEthersError(error);
+      }
     }
   }
 
   async signAndSendTransaction({
     params,
     context,
-  }: WalletMethodParams<[IncomingTransaction, TransactionContextParams]>) {
+  }: WalletMethodParams<[IncomingTransactionAA, TransactionContextParams]>) {
     this.verifyInternalOrigin(context);
     this.ensureStringOrigin(context);
     const [transaction, transactionContextParams] = params;

src/background/Wallet/Wallet.ts

@@ -8,6 +8,7 @@ export const SOCIAL_API_URL = process.env.SOCIAL_API_URL;
 export const BACKEND_ENV = process.env.BACKEND_ENV;
 export const MIXPANEL_TOKEN_PUBLIC = process.env.MIXPANEL_TOKEN_PUBLIC;
 export const SLOW_MODE = false;
+export const FEATURE_PAYMASTER_ENABLED = process.env.FEATURE_PAYMASTER === 'on';
 
 if (!PROXY_URL) {
   throw new Error('PROXY_URL must be defined in ENV');

src/env/config.ts

@@ -0,0 +1,35 @@
+import type { types as zkSyncTypes } from 'zksync-ethers';
+import { EIP712Signer, utils as zkSyncUtils } from 'zksync-ethers';
+import { invariant } from 'src/shared/invariant';
+import { normalizeChainId } from 'src/shared/normalizeChainId';
+
+/**
+ * Creates an "EIP-712 transaction": a TypedData object
+ * that the user signs. The signature will be used when serializing the TransactionRequest
+ */
+export function createTypedData(transaction: zkSyncTypes.TransactionRequest) {
+  invariant(
+    Boolean(transaction.customData),
+    'createTypedData expects a transaction with paymaster data'
+  );
+  const { chainId } = transaction;
+  invariant(chainId, 'ChainId missing from TransactionRequest');
+  const chainIdAsIntString = String(parseInt(normalizeChainId(chainId)));
+  return {
+    types: {
+      Transaction: zkSyncUtils.EIP712_TYPES.Transaction,
+      EIP712Domain: [
+        { name: 'name', type: 'string' },
+        { name: 'version', type: 'string' },
+        { name: 'chainId', type: 'uint256' },
+      ],
+    },
+    domain: {
+      name: 'zkSync',
+      version: '2',
+      chainId: chainIdAsIntString,
+    },
+    primaryType: 'Transaction',
+    message: EIP712Signer.getSignInput(transaction),
+  };
+}

src/modules/ethereum/account-abstraction/createTypedData.ts

@@ -7,6 +7,7 @@ import {
 } from 'src/modules/defi-sdk/queries';
 import type { Networks } from 'src/modules/networks/Networks';
 import type { Chain } from 'src/modules/networks/Chain';
+import type { BigNumberish } from 'ethers';
 import { ethers } from 'ethers';
 import { UnsupportedNetwork } from 'src/modules/networks/errors';
 import { normalizeChainId } from 'src/shared/normalizeChainId';
@@ -171,7 +172,7 @@ export async function pendingTransactionToAddressAction(
 export async function incomingTxToIncomingAddressAction(
   transactionObject: {
     transaction: IncomingTransactionWithChainId & {
-      nonce?: number;
+      nonce?: BigNumberish;
       from: string;
     };
   } & Pick<TransactionObject, 'hash' | 'receipt' | 'timestamp' | 'dropped'>,
@@ -191,7 +192,10 @@ export async function incomingTxToIncomingAddressAction(
       chain: chain.toString(),
       status: 'pending',
       fee: null,
-      nonce: transaction.nonce ?? -1,
+      // nonce can be "BigNumberish" due to
+      // ethers types: {import("@ethersproject/abstract-provider").TransactionRequest}
+      // Converting bignumber to number cannot be safe, but can nonce be really > MAX_SAFE_INTEGER?
+      nonce: (transaction.nonce as number) ?? -1,
     },
     datetime: new Date(timestamp ?? Date.now()).toISOString(),
     label,

src/modules/ethereum/transactions/addressAction/creators.ts

@@ -47,7 +47,7 @@ async function fetchGasPriceForTransaction(
   return fetchGasPrice(chain, networks);
 }
 
-function hasGasEstimation(transaction: IncomingTransaction) {
+export function hasGasEstimation(transaction: IncomingTransaction) {
   const gas = getGas(transaction);
   return gas && !ethers.BigNumber.from(gas).isZero();
 }

src/modules/ethereum/transactions/fetchAndAssignGasPrice.ts

@@ -1,8 +1,12 @@
 import { valueToHex } from 'src/shared/units/valueToHex';
-import type { UnsignedTransaction } from '../types/UnsignedTransaction';
-import type { IncomingTransaction } from '../types/IncomingTransaction';
+import type { types as zkSyncTypes } from 'zksync-ethers';
+import type { TransactionRequest } from '@ethersproject/abstract-provider';
+import type { IncomingTransactionAA } from '../types/IncomingTransaction';
 
-const knownFields: Array<keyof UnsignedTransaction> = [
+const knownFields: Array<
+  | (keyof TransactionRequest & zkSyncTypes.TransactionRequest)
+  | 'gasPerPubdataByteLimit'
+> = [
   'from',
   'to',
   'nonce',
@@ -15,14 +19,15 @@ const knownFields: Array<keyof UnsignedTransaction> = [
   'gasPrice',
   'maxPriorityFeePerGas',
   'maxFeePerGas',
+  'customData',
+  'gasPerPubdataByteLimit',
 ];
 
-export function prepareTransaction(incomingTransaction: IncomingTransaction) {
-  const transaction: UnsignedTransaction = {};
+export function prepareTransaction(incomingTransaction: IncomingTransactionAA) {
+  const transaction: zkSyncTypes.TransactionRequest = {};
   for (const field of knownFields) {
-    const knownField = field as keyof UnsignedTransaction;
+    const knownField = field as keyof TransactionRequest;
     if (incomingTransaction[knownField] !== undefined) {
-      // TODO: convert using `valueToHex` each value?
       // @ts-ignore
       transaction[knownField] = incomingTransaction[knownField];
     }