feat: account abstraction and paymaster syntax

package.json

@@ -44,7 +44,11 @@
         "ethers": "^6.7.1"
     },
     "scripts": {
-        "test": "mocha -r ts-node/register --bail tests/setup.test.ts tests/unit/*.test.ts tests/integration/*.test.ts",
+        "test": "yarn test:unit && yarn test:integration",
+            "test:unit": "mocha -r ts-node/register --bail tests/unit/*.test.ts",
+            "test:integration": "mocha -r ts-node/register --bail tests/setup.test.ts tests/integration/*.test.ts",
+                "test:aa": "yarn test:unit && yarn test:aa:wallet",
+                "test:aa:wallet": "mocha -r ts-node/register --bail tests/integration/wallet.test.ts --grep 'AbstractWallet'",
         "build": "yarn types && tsc --strict true && ncp ./abi ./build/abi",
         "lint": "prettier . --write",
         "lint:check": "prettier . --check",

src/index.ts

@@ -1,6 +1,7 @@
 export * as utils from "./utils";
 export * as types from "./types";
 export { EIP712Signer, Signer, L1Signer } from "./signer";
-export { Wallet } from "./wallet";
+export { Wallet, AbstractWallet, signingFunction } from "./wallet";
 export { BrowserProvider, Provider } from "./provider";
 export { ContractFactory, Contract } from "./contract";
+export { Paymaster } from "./paymaster";

src/paymaster.ts

@@ -0,0 +1,37 @@
+import { getAddress } from "ethers";
+import { ApprovalBasedPaymasterInput, GeneralPaymasterInput } from "./types";
+import { encodeData, getPaymasterParams } from "./utils";
+
+export class Paymaster {
+    type: string;
+    address: string;
+    paymasterInput: ApprovalBasedPaymasterInput | GeneralPaymasterInput;
+
+    constructor(
+        type: "ApprovalBased" | "General",
+        address: string,
+        tokenAddress: string = "",
+        minimalAllowance: number = 1,
+        innerInput: any[] = [],
+    ) {
+        this.type = type;
+        this.address = getAddress(address);
+        const encodedInnerInput = encodeData(innerInput);
+        this.paymasterInput =
+            type == "ApprovalBased"
+                ? {
+                      type,
+                      token: getAddress(tokenAddress),
+                      minimalAllowance,
+                      innerInput: encodedInnerInput,
+                  }
+                : {
+                      type,
+                      innerInput: encodedInnerInput,
+                  };
+    }
+
+    getPaymasterParams() {
+        return getPaymasterParams(this.address, this.paymasterInput);
+    }
+}

src/utils.ts

@@ -1,4 +1,7 @@
 import { AbiCoder, BigNumberish, BytesLike, ethers, SignatureLike } from "ethers";
+import { IERC20__factory, IL1Bridge__factory } from "../typechain";
+import { Provider } from "./provider";
+import { EIP712Signer } from "./signer";
 import {
     Address,
     DeploymentInfo,
@@ -7,11 +10,8 @@ import {
     PaymasterParams,
     PriorityOpTree,
     PriorityQueueType,
-    TransactionLike,
+    TransactionLike
 } from "./types";
-import { Provider } from "./provider";
-import { EIP712Signer } from "./signer";
-import { IERC20__factory, IL1Bridge__factory } from "../typechain";
 
 export * from "./paymaster-utils";
 
@@ -594,3 +594,24 @@ export async function estimateCustomBridgeDepositL2Gas(
         l2Value: l2Value,
     });
 }
+
+export function encodeData(data: any[]): string {
+    const types = data.map(item => {
+        if (typeof item === 'number') {
+            return 'uint256';
+        } else if (typeof item === 'string') {
+            return 'string';
+        } else if (typeof item === 'boolean') {
+            return 'bool';
+        } else if (Array.isArray(item)) {
+            throw new Error('Nested arrays are not supported');
+        } else if (typeof item === 'object' && item !== null) {
+            throw new Error('Nested objects are not supported');
+        }
+        throw new Error(`Unsupported data type: ${typeof item}`);
+    });
+
+    const coder = new AbiCoder();
+    const encodedData = coder.encode(types, data);
+    return encodedData;
+}

src/wallet.ts

@@ -1,9 +1,10 @@
-import { EIP712Signer } from "./signer";
+import { ProgressCallback, ethers } from "ethers";
+import { AdapterL1, AdapterL2 } from "./adapters";
+import { Paymaster } from "./paymaster";
 import { Provider } from "./provider";
-import { EIP712_TX_TYPE, serializeEip712 } from "./utils";
-import { ethers, ProgressCallback } from "ethers";
+import { EIP712Signer } from "./signer";
 import { TransactionLike, TransactionRequest, TransactionResponse } from "./types";
-import { AdapterL1, AdapterL2 } from "./adapters";
+import { DEFAULT_GAS_PER_PUBDATA_LIMIT, EIP712_TX_TYPE, serializeEip712 } from "./utils";
 
 export class Wallet extends AdapterL2(AdapterL1(ethers.Wallet)) {
     // @ts-ignore
@@ -124,3 +125,52 @@ export class Wallet extends AdapterL2(AdapterL1(ethers.Wallet)) {
         return await this.provider.broadcastTransaction(await this.signTransaction(populatedTx));
     }
 }
+
+interface SigningFunction {
+    (this: AbstractWallet, transaction: TransactionRequest): Promise<string>;
+}
+
+export class AbstractWallet extends Wallet {
+    readonly accountAddress: string;
+    paymaster: Paymaster;
+    customSigningFunction: SigningFunction;
+
+    constructor(
+        accountAddress: string,
+        privateKey: string,
+        providerL2?: Provider,
+        providerL1?: ethers.Provider,
+        paymaster: Paymaster | null = null,
+        customSigningFunction: SigningFunction = signingFunction,
+    ) {
+        super(privateKey, providerL2);
+        this.accountAddress = accountAddress;
+        this.paymaster = paymaster;
+        this.providerL1 = providerL1;
+        this.customSigningFunction = customSigningFunction.bind(this);
+    }
+
+    override transfer(transaction: { to: string; amount: ethers.BigNumberish; token?: string; overrides?: ethers.Overrides; }): Promise<TransactionResponse> {
+        transaction.overrides = { type: EIP712_TX_TYPE };
+        return super.transfer(transaction);
+    }
+
+    override getAddress(): Promise<string> {
+        return Promise.resolve(this.accountAddress);
+    }
+
+    override async signTransaction(transaction: TransactionRequest): Promise<string> {
+        return this.customSigningFunction(transaction);
+    }
+}
+
+export async function signingFunction(this: AbstractWallet, transaction: TransactionRequest): Promise<string> {
+    transaction.customData = this.paymaster ? {
+        gasPerPubdata: DEFAULT_GAS_PER_PUBDATA_LIMIT,
+        paymasterParams: this.paymaster.getPaymasterParams(),
+    } : {};
+    transaction.customData = this._fillCustomData(transaction.customData);
+    transaction.customData.customSignature = await this.eip712.sign(transaction);
+    // @ts-ignore
+    return (0, serializeEip712)(transaction);
+}