Initial EIP-7702 support (#4916).

Author: ricmoo

docs.wrm/links/specs.txt

@@ -34,6 +34,7 @@ link-eip-2930 [EIP-2930](https://eips.ethereum.org/EIPS/eip-2930)
 link-eip-4788 [EIP-4844](https://eips.ethereum.org/EIPS/eip-4788)
 link-eip-4844 [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844)
 link-eip-6963 [EIP-6963](https://eips.ethereum.org/EIPS/eip-6963)
+link-eip-7702 [EIP-7702](https://eips.ethereum.org/EIPS/eip-7702)
 
 # Open Standards
 link-base58 [Base58](https://en.bitcoinwiki.org/wiki/Base58)

src.ts/ethers.ts

@@ -49,6 +49,7 @@ export {
 export {
     id,
     ensNormalize, isValidName, namehash, dnsEncode,
+    hashAuthorization, verifyAuthorization,
     hashMessage, verifyMessage,
     solidityPacked, solidityPackedKeccak256, solidityPackedSha256,
     TypedDataEncoder,
@@ -89,7 +90,7 @@ export {
 } from "./providers/index.js";
 
 export {
-    accessListify,
+    accessListify, authorizationify,
     computeAddress, recoverAddress,
     Transaction
 } from "./transaction/index.js";
@@ -159,7 +160,9 @@ export type {
 
 export type { ProgressCallback, SignatureLike } from "./crypto/index.js";
 
-export type { TypedDataDomain, TypedDataField } from "./hash/index.js";
+export type {
+    AuthorizationRequest, TypedDataDomain, TypedDataField
+} from "./hash/index.js";
 
 export type {
     Provider, Signer,
@@ -182,6 +185,7 @@ export type {
 
 export type {
     AccessList, AccessListish, AccessListEntry,
+    Authorization, AuthorizationLike,
     Blob, BlobLike, KzgLibrary, KzgLibraryLike,
     TransactionLike
 } from "./transaction/index.js";

src.ts/hash/authorization.ts

@@ -0,0 +1,38 @@
+import { getAddress } from "../address/index.js";
+import { keccak256 } from "../crypto/index.js";
+import { recoverAddress } from "../transaction/index.js";
+import {
+    assertArgument, concat, encodeRlp, toBeArray
+} from "../utils/index.js";
+
+import type { Addressable } from "../address/index.js";
+import type { SignatureLike } from "../crypto/index.js";
+import type { BigNumberish, Numeric } from "../utils/index.js";
+
+export interface AuthorizationRequest {
+    address: string | Addressable;
+    nonce?: Numeric;
+    chainId?: BigNumberish;
+}
+
+/**
+ *  Computes the [[link-eip-7702]] authorization digest to sign.
+ */
+export function hashAuthorization(auth: AuthorizationRequest): string {
+    assertArgument(typeof(auth.address) === "string", "invalid address for hashAuthorization", "auth.address", auth);
+    return keccak256(concat([
+        "0x05", encodeRlp([
+            (auth.chainId != null) ? toBeArray(auth.chainId): "0x",
+            getAddress(auth.address),
+            (auth.nonce != null) ? toBeArray(auth.nonce): "0x",
+        ])
+    ]));
+}
+
+/**
+ *  Return the address of the private key that produced
+ *  the signature %%sig%% during signing for %%message%%.
+ */
+export function verifyAuthorization(auth: AuthorizationRequest, sig: SignatureLike): string {
+    return recoverAddress(hashAuthorization(auth), sig);
+}

src.ts/hash/index.ts

@@ -5,6 +5,7 @@
  *  @_section: api/hashing:Hashing Utilities  [about-hashing]
  */
 
+export { hashAuthorization, verifyAuthorization } from "./authorization.js";
 export { id } from "./id.js"
 export { ensNormalize, isValidName, namehash, dnsEncode } from "./namehash.js";
 export { hashMessage, verifyMessage } from "./message.js";
@@ -13,4 +14,5 @@ export {
 } from "./solidity.js";
 export { TypedDataEncoder, verifyTypedData } from "./typed-data.js";
 
+export type { AuthorizationRequest } from "./authorization.js";
 export type { TypedDataDomain, TypedDataField } from "./typed-data.js";

src.ts/providers/abstract-signer.ts

@@ -14,15 +14,16 @@ import {
 
 import { copyRequest } from "./provider.js";
 
-import type { TypedDataDomain, TypedDataField } from "../hash/index.js";
-import type { TransactionLike } from "../transaction/index.js";
+import type {
+    AuthorizationRequest, TypedDataDomain, TypedDataField
+} from "../hash/index.js";
+import type { Authorization, TransactionLike } from "../transaction/index.js";
 
 import type {
     BlockTag, Provider, TransactionRequest, TransactionResponse
 } from "./provider.js";
 import type { Signer } from "./signer.js";
 
-
 function checkProvider(signer: AbstractSigner, operation: string): Provider {
     if (signer.provider) { return signer.provider; }
     assert(false, "missing provider", "UNSUPPORTED_OPERATION", { operation });
@@ -194,7 +195,7 @@ export abstract class AbstractSigner<P extends null | Provider = null | Provider
                         operation: "signer.getFeeData" });
                 }
 
-            } else if (pop.type === 2 || pop.type === 3) {
+            } else if (pop.type === 2 || pop.type === 3 || pop.type === 4) {
                 // Explicitly using EIP-1559 or EIP-4844
 
                 // Populate missing fee data
@@ -213,6 +214,21 @@ export abstract class AbstractSigner<P extends null | Provider = null | Provider
         return await resolveProperties(pop);
     }
 
+    async populateAuthorization(_auth: AuthorizationRequest): Promise<AuthorizationRequest> {
+        const auth = Object.assign({ }, _auth);
+
+        // Add a chain ID if not explicitly set to 0
+        if (auth.chainId == null) {
+            auth.chainId = (await checkProvider(this, "getNetwork").getNetwork()).chainId;
+        }
+
+        // @TODO: Take chain ID into account when populating noce?
+
+        if (auth.nonce == null) { auth.nonce = await this.getNonce(); }
+
+        return auth;
+    }
+
     async estimateGas(tx: TransactionRequest): Promise<bigint> {
         return checkProvider(this, "estimateGas").estimateGas(await this.populateCall(tx));
     }
@@ -235,6 +251,12 @@ export abstract class AbstractSigner<P extends null | Provider = null | Provider
         return await provider.broadcastTransaction(await this.signTransaction(txObj));
     }
 
+    // @TODO: in v7 move this to be abstract
+    authorize(authorization: AuthorizationRequest): Promise<Authorization> {
+        assert(false, "authorization not implemented for this signer",
+          "UNSUPPORTED_OPERATION", { operation: "authorize" });
+    }
+
     abstract signTransaction(tx: TransactionRequest): Promise<string>;
     abstract signMessage(message: string | Uint8Array): Promise<string>;
     abstract signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;

src.ts/providers/format.ts

@@ -214,6 +214,15 @@ export function formatTransactionResponse(value: any): TransactionResponseParams
         accessList: allowNull(accessListify, null),
         blobVersionedHashes: allowNull(arrayOf(formatHash, true), null),
 
+        authorizationList: allowNull(arrayOf((v: any) => {
+            return {
+                address: getAddress(v.address),
+                chainId: getBigInt(v.chainId),
+                nonce: getBigInt(v.nonce),
+                signature: Signature.from(v.signature ? v.signature: v)
+            };
+        }, false), null),
+
         blockHash: allowNull(formatHash, null),
         blockNumber: allowNull(getNumber, null),
         transactionIndex: allowNull(getNumber, null),

src.ts/providers/formatting.ts

@@ -5,7 +5,7 @@
  */
 
 import type { Signature } from "../crypto/index.js";
-import type { AccessList } from "../transaction/index.js";
+import type { Authorization, AccessList } from "../transaction/index.js";
 
 
 //////////////////////
@@ -283,6 +283,7 @@ export interface TransactionReceiptParams {
      *  post-byzantium blocks this is null.
      */
     root: null | string;
+
 }
 
 /*
@@ -406,7 +407,12 @@ export interface TransactionResponseParams {
     /**
      *  The [[link-eip-4844]] BLOb versioned hashes.
      */
-    blobVersionedHashes?: null | Array<string>;
+    blobVersionedHashes?: null | Array<string>;  // @TODO: drop the "?"? (v7)
+
+    /**
+     *  The [[link-eip-7702]] authorizations (if any).
+     */
+    authorizationList: null | Array<Authorization>;
 };
 
 

src.ts/providers/provider-jsonrpc.ts

@@ -18,7 +18,7 @@
 import { AbiCoder } from "../abi/index.js";
 import { getAddress, resolveAddress } from "../address/index.js";
 import { TypedDataEncoder } from "../hash/index.js";
-import { accessListify } from "../transaction/index.js";
+import { accessListify, authorizationify } from "../transaction/index.js";
 import {
     defineProperties, getBigInt, hexlify, isHexString, toQuantity, toUtf8Bytes,
     isError, makeError, assert, assertArgument,
@@ -277,6 +277,14 @@ export interface JsonRpcTransactionRequest {
       *  The transaction access list.
       */
      accessList?: Array<{ address: string, storageKeys: Array<string> }>;
+
+     /**
+      *  The transaction authorization list.
+      */
+     authorizationList?: Array<{
+         address: string, nonce: string, chainId: string,
+         yParity: string, r: string, s: string
+     }>;
 }
 
 // @TODO: Unchecked Signers
@@ -850,6 +858,20 @@ export abstract class JsonRpcApiProvider extends AbstractProvider {
             (<any>result)["blobVersionedHashes"] = tx.blobVersionedHashes.map(h => h.toLowerCase());
         }
 
+        if (tx.authorizationList) {
+            result["authorizationList"] = tx.authorizationList.map((_a) => {
+                const a = authorizationify(_a);
+                return {
+                    address: a.address,
+                    nonce: toQuantity(a.nonce),
+                    chainId: toQuantity(a.chainId),
+                    yParity: toQuantity(a.signature.yParity),
+                    r: a.signature.r,
+                    s: a.signature.s,
+                }
+            });
+        }
+
         // @TODO: blobs should probably also be copied over, optionally
         // accounting for the kzg property to backfill blobVersionedHashes
         // using the commitment. Or should that be left as an exercise to

src.ts/providers/provider.ts

@@ -10,7 +10,8 @@ import type { AddressLike, NameResolver } from "../address/index.js";
 import type { BigNumberish, EventEmitterable } from "../utils/index.js";
 import type { Signature } from "../crypto/index.js";
 import type {
-    AccessList, AccessListish, BlobLike, KzgLibraryLike, TransactionLike
+    AccessList, AccessListish, Authorization, AuthorizationLike, BlobLike,
+    KzgLibraryLike, TransactionLike
 } from "../transaction/index.js";
 
 import type { ContractRunner } from "./contracts.js";
@@ -241,6 +242,11 @@ export interface TransactionRequest {
      */
     kzg?: null | KzgLibraryLike;
 
+    /**
+     *  The [[link-eip-7702]] authorizations (if any).
+     */
+    authorizationList?: null | Array<AuthorizationLike>;
+
     // Todo?
     //gasMultiplier?: number;
 };
@@ -319,6 +325,11 @@ export interface PreparedTransactionRequest {
      */
     accessList?: AccessList;
 
+    /**
+     *  The [[link-eip-7702]] authorizations (if any).
+     */
+    authorizationList?: Array<Authorization>;
+
     /**
      *  A custom object, which can be passed along for network-specific
      *  values.
@@ -375,6 +386,10 @@ export function copyRequest(req: TransactionRequest): PreparedTransactionRequest
         result.accessList = accessListify(req.accessList);
     }
 
+    if (req.authorizationList) {
+        result.authorizationList = req.authorizationList.slice();
+    }
+
     if ("blockTag" in req) { result.blockTag = req.blockTag; }
 
     if ("enableCcipRead" in req) {
@@ -1375,6 +1390,11 @@ export class TransactionResponse implements TransactionLike<string>, Transaction
      */
     readonly blobVersionedHashes!: null | Array<string>;
 
+    /**
+     *  The [[link-eip-7702]] authorizations (if any).
+     */
+    readonly authorizationList!: null | Array<Authorization>;
+
     #startBlock: number;
 
     /**
@@ -1410,6 +1430,8 @@ export class TransactionResponse implements TransactionLike<string>, Transaction
         this.accessList = (tx.accessList != null) ? tx.accessList: null;
         this.blobVersionedHashes = (tx.blobVersionedHashes != null) ? tx.blobVersionedHashes: null;
 
+        this.authorizationList = (tx.authorizationList != null) ? tx.authorizationList: null;
+
         this.#startBlock = -1;
     }
 

src.ts/providers/signer.ts

@@ -1,7 +1,9 @@
 
 import type { Addressable, NameResolver } from "../address/index.js";
-import type { TypedDataDomain, TypedDataField } from "../hash/index.js";
-import type { TransactionLike } from "../transaction/index.js";
+import type {
+    AuthorizationRequest, TypedDataDomain, TypedDataField
+} from "../hash/index.js";
+import type { Authorization, TransactionLike } from "../transaction/index.js";
 
 import type { ContractRunner } from "./contracts.js";
 import type { BlockTag, Provider, TransactionRequest, TransactionResponse } from "./provider.js";
@@ -146,4 +148,19 @@ export interface Signer extends Addressable, ContractRunner, NameResolver {
      *  Signs the [[link-eip-712]] typed data.
      */
     signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
+
+    /**
+     *  Prepares an [[AuthorizationRequest]] for authorization by
+     *  populating any missing properties:
+     *  - resolves ``address`` (if an Addressable or ENS name)
+     *  - populates ``nonce`` via ``signer.getNonce("pending")``
+     *  - populates ``chainId`` via ``signer.provider.getNetwork()``
+     */
+    populateAuthorization(auth: AuthorizationRequest): Promise<AuthorizationRequest>;
+
+    /**
+     *  Signs an %%authorization%% to be used in [[link-eip-7702]]
+     *  transactions.
+     */
+    authorize(authorization: AuthorizationRequest): Promise<Authorization>;
 }

src.ts/transaction/authorization.ts

@@ -0,0 +1,14 @@
+import { getAddress } from "../address/index.js";
+import { Signature } from "../crypto/index.js";
+import { getBigInt } from "../utils/index.js";
+
+import type { Authorization, AuthorizationLike } from "./index.js";
+
+export function authorizationify(auth: AuthorizationLike): Authorization {
+    return {
+        address: getAddress(auth.address),
+        nonce: getBigInt((auth.nonce != null) ? auth.nonce: 0),
+        chainId: getBigInt((auth.chainId != null)? auth.chainId: 0),
+        signature: Signature.from(auth.signature)
+    };
+}

src.ts/transaction/index.ts

@@ -6,6 +6,9 @@
 
 null;
 
+import type { BigNumberish } from "../utils/maths.js";
+import type { Signature, SignatureLike } from "../crypto/index.js";
+
 /**
  *  A single [[AccessList]] entry of storage keys (slots) for an address.
  */
@@ -23,8 +26,23 @@ export type AccessListish = AccessList |
                             Array<[ string, Array<string> ]> |
                             Record<string, Array<string>>;
 
+// Keep here?
+export interface Authorization {
+    address: string;
+    nonce: bigint;
+    chainId: bigint;
+    signature: Signature;
+}
+
+export type AuthorizationLike = {
+    address: string;
+    nonce: BigNumberish;
+    chainId: BigNumberish;
+    signature: SignatureLike
+};
 
 export { accessListify } from "./accesslist.js";
+export { authorizationify } from "./authorization.js";
 export { computeAddress, recoverAddress } from "./address.js";
 export { Transaction } from "./transaction.js";