fix: update ethers dependency to 6.14.3 and refactor authorization types to use native Authorization

Author: zy0n

package.json

@@ -56,7 +56,7 @@
     "chai-as-promised": "^7.1.1",
     "encoding-down": "^7.1.0",
     "ethereum-cryptography": "^2.0.0",
-    "ethers": "6.13.1",
+    "ethers": "6.14.3",
     "fast-text-encoding": "^1.0.6",
     "levelup": "^5.1.1",
     "msgpack-lite": "^0.1.26"

src/contracts/relay-adapt/V2/relay-adapt-7702.ts

@@ -8,6 +8,7 @@ import {
   Result,
   Log,
   toUtf8String,
+  Authorization,
 } from 'ethers';
 import { ABIRelayAdapt, ABIRelayAdapt7702 } from '../../../abi/abi';
 import { TransactionReceiptLog } from '../../../models/formatted-types';
@@ -20,7 +21,6 @@ import { RelayAdapt } from '../../../abi/typechain/RelayAdapt';
 import { PayableOverrides } from '../../../abi/typechain/common';
 import { TransactionStructV2 } from '../../../models/transaction-types';
 import { MINIMUM_RELAY_ADAPT_CROSS_CONTRACT_CALLS_GAS_LIMIT_V2 } from '../constants';
-import { EIP7702Authorization } from '../../../models/relay-adapt-types';
 import { ByteUtils } from '../../../utils/bytes';
 
 enum RelayAdaptEvent {
@@ -51,7 +51,7 @@ export class RelayAdapt7702Contract {
 
   async populateShieldBaseToken(
     shieldRequest: ShieldRequestStruct,
-    authorization?: EIP7702Authorization,
+    authorization?: Authorization,
     signature?: string,
     random31Bytes?: string,
     ephemeralAddress?: string,
@@ -164,7 +164,7 @@ export class RelayAdapt7702Contract {
     random31Bytes: string,
     _useDummyProof: boolean,
     sendWithPublicWallet: boolean,
-    authorization?: EIP7702Authorization,
+    authorization?: Authorization,
     signature?: string,
     ephemeralAddress?: string,
   ): Promise<ContractTransaction> {
@@ -270,7 +270,7 @@ export class RelayAdapt7702Contract {
     isGasEstimate: boolean,
     isBroadcasterTransaction: boolean,
     minGasLimit?: bigint,
-    authorization?: EIP7702Authorization,
+    authorization?: Authorization,
     signature?: string,
     ephemeralAddress?: string,
   ): Promise<ContractTransaction> {
@@ -367,7 +367,7 @@ export class RelayAdapt7702Contract {
   private async populateRelayMulticall(
     calls: ContractTransaction[],
     overrides: PayableOverrides,
-    authorization?: EIP7702Authorization,
+    authorization?: Authorization,
     signature?: string,
     random31Bytes?: string,
     ephemeralAddress?: string,
@@ -403,7 +403,7 @@ export class RelayAdapt7702Contract {
     calls: ContractTransaction[],
     overrides: PayableOverrides,
     minimumGasLimit = BigInt(0),
-    authorization?: EIP7702Authorization,
+    authorization?: Authorization,
     signature?: string,
     ephemeralAddress?: string,
   ): Promise<ContractTransaction> {

src/contracts/relay-adapt/relay-adapt-7702-helper.ts

@@ -1,4 +1,4 @@
-import { ContractTransaction, AbiCoder, keccak256, Wallet, encodeRlp, toBeHex, concat, Interface, HDNodeWallet } from 'ethers';
+import { ContractTransaction, AbiCoder, keccak256, Wallet, Interface, HDNodeWallet, Authorization } from 'ethers';
 import { ByteUtils } from '../../utils/bytes';
 import { ShieldNoteERC20 } from '../../note/erc20/shield-note-erc20';
 import { AddressData, decodeAddress } from '../../key-derivation';
@@ -12,35 +12,25 @@ import { ShieldNoteNFT } from '../../note/nft/shield-note-nft';
 import { ERC721_NOTE_VALUE } from '../../note/note-util';
 import { RelayAdapt, ShieldRequestStruct } from '../../abi/typechain/RelayAdapt';
 import { TransactionStructV2, TransactionStructV3 } from '../../models/transaction-types';
-import { EIP7702Authorization } from '../../models/relay-adapt-types';
 import { ABIRelayAdapt7702 } from '../../abi/abi';
+import { signEIP7702Authorization as signEIP7702AuthorizationCore } from '../../transaction/eip7702';
 
 class RelayAdapt7702Helper {
+  /**
+   * Signs an EIP-7702 Authorization using ethers native methods.
+   * @param signer - The ephemeral key signer
+   * @param contractAddress - The address to delegate to (RelayAdapt7702)
+   * @param chainId - Chain ID
+   * @param nonce - Nonce (typically 0 for ephemeral keys)
+   * @returns Authorization tuple
+   */
   static async signEIP7702Authorization(
     signer: Wallet | HDNodeWallet,
     contractAddress: string,
     chainId: bigint,
     nonce: number,
-  ): Promise<EIP7702Authorization> {
-    // 0x05 || rlp([chain_id, address, nonce])
-    const rlpEncoded = encodeRlp([
-      toBeHex(chainId),
-      contractAddress,
-      toBeHex(nonce),
-    ]);
-    const payload = concat(['0x05', rlpEncoded]);
-    const digest = keccak256(payload);
-
-    const signature = signer.signingKey.sign(digest);
-
-    return {
-      chainId: chainId.toString(),
-      address: contractAddress,
-      nonce,
-      yParity: signature.yParity,
-      r: signature.r,
-      s: signature.s,
-    };
+  ): Promise<Authorization> {
+    return signEIP7702AuthorizationCore(signer, contractAddress, chainId, nonce);
   }
 
   static async signExecutionAuthorization(

src/contracts/relay-adapt/relay-adapt-versioned-smart-contracts.ts

@@ -1,4 +1,4 @@
-import { ContractTransaction, Provider, TransactionRequest } from 'ethers';
+import { ContractTransaction, Provider, TransactionRequest, Authorization } from 'ethers';
 import { ContractStore } from '../contract-store';
 import { Chain } from '../../models/engine-types';
 import { TXIDVersion } from '../../models/poi-types';
@@ -7,7 +7,6 @@ import { TransactionReceiptLog, TransactionStructV2, TransactionStructV3 } from
 import { RelayAdaptV2Contract } from './V2/relay-adapt-v2';
 import { RelayAdapt7702Contract } from './V2/relay-adapt-7702';
 import { RelayAdaptV3Contract } from './V3/relay-adapt-v3';
-import { EIP7702Authorization } from '../../models/relay-adapt-types';
 
 export class RelayAdaptVersionedSmartContracts {
   static getRelayAdaptContract(txidVersion: TXIDVersion, chain: Chain, isRelayAdapt7702 = false) {
@@ -30,7 +29,7 @@ export class RelayAdaptVersionedSmartContracts {
     chain: Chain,
     shieldRequest: ShieldRequestStruct,
     isRelayAdapt7702 = false,
-    authorization?: EIP7702Authorization,
+    authorization?: Authorization,
     signature?: string,
     random31Bytes?: string,
     ephemeralAddress?: string,
@@ -59,7 +58,7 @@ export class RelayAdaptVersionedSmartContracts {
     useDummyProof: boolean,
     sendWithPublicWallet: boolean,
     isRelayAdapt7702 = false,
-    authorization?: EIP7702Authorization,
+    authorization?: Authorization,
     signature?: string,
     ephemeralAddress?: string,
   ): Promise<ContractTransaction> {
@@ -110,7 +109,7 @@ export class RelayAdaptVersionedSmartContracts {
     isBroadcasterTransaction: boolean,
     minGasLimit?: bigint,
     isRelayAdapt7702 = false,
-    authorization?: EIP7702Authorization,
+    authorization?: Authorization,
     signature?: string,
     ephemeralAddress?: string,
   ): Promise<ContractTransaction> {

src/models/relay-adapt-types.ts

@@ -1,19 +1,11 @@
+import { Authorization } from 'ethers';
 import { TransactionStructV2 } from './transaction-types';
 import { RelayAdapt } from '../abi/typechain/RelayAdapt';
 
-export interface EIP7702Authorization {
-  chainId: string;
-  address: string;
-  nonce: number;
-  yParity: 0 | 1;
-  r: string;
-  s: string;
-}
-
 export interface RelayAdapt7702Request {
   transactions: TransactionStructV2[];
   actionData: RelayAdapt.ActionDataStruct;
-  authorization: EIP7702Authorization;
+  authorization: Authorization;
   executionSignature: string;
   ephemeralAddress: string;
 }

src/transaction/__tests__/eip7702.test.ts

@@ -10,28 +10,24 @@ function toRlpInteger(value: number): string | Uint8Array {
 }
 
 describe('EIP-7702 Signing', () => {
-  it('should sign and recover correctly', () => {
+  it('should sign and recover correctly', async () => {
     const signer = Wallet.createRandom();
     const contractAddress = '0x1234567890123456789012345678901234567890';
-    const chainId = 1;
+    const chainId = 1n;
     const nonce = 0;
 
-    const auth = signEIP7702Authorization(signer, contractAddress, chainId, nonce);
+    const auth = await signEIP7702Authorization(signer, contractAddress, chainId, nonce);
 
     // Reconstruct hash
     const rlpEncoded = encodeRlp([
-      toRlpInteger(chainId),
+      toRlpInteger(Number(chainId)),
       contractAddress,
       toRlpInteger(nonce)
     ]);
     const payload = new Uint8Array([0x05, ...getBytes(rlpEncoded)]);
     const hash = keccak256(payload);
 
-    const recovered = recoverAddress(hash, {
-      r: auth.r,
-      s: auth.s,
-      yParity: auth.yParity,
-    });
+    const recovered = recoverAddress(hash, auth.signature);
 
     expect(recovered).to.equal(signer.address);
   });

src/transaction/eip7702.ts

@@ -1,49 +1,27 @@
-import { HDNodeWallet, Wallet, keccak256, encodeRlp, getBytes, toBeHex } from 'ethers';
-import { EIP7702Authorization } from '../models/relay-adapt-types';
-
-function toRlpInteger(value: number): string | Uint8Array {
-  if (value === 0) {
-    return new Uint8Array(0);
-  }
-  return toBeHex(value);
-}
+import { HDNodeWallet, Wallet, Authorization } from 'ethers';
 
 /**
- * Signs an EIP-7702 Authorization Tuple.
- * Payload: 0x05 || rlp([chain_id, address, nonce])
+ * Signs an EIP-7702 Authorization Tuple using ethers native methods.
  * @param signer - The ephemeral key signer
  * @param contractAddress - The address to delegate to (RelayAdapt7702)
- * @param chainId - Chain ID
- * @param nonce - Nonce (default 0)
- * @returns EIP7702Authorization
+ * @param chainId - Chain ID (optional - will be auto-populated if not provided)
+ * @param nonce - Nonce (optional - will be auto-populated if not provided)
+ * @returns Authorization
  */
-export const signEIP7702Authorization = (
+export const signEIP7702Authorization = async (
   signer: HDNodeWallet | Wallet,
   contractAddress: string,
-  chainId: number,
-  nonce: number = 0
-): EIP7702Authorization => {
-  // RLP encode the tuple [chain_id, address, nonce]
-  // We use toRlpInteger to ensure numbers are formatted correctly for RLP (0 -> empty bytes, others -> hex)
-  const rlpEncoded = encodeRlp([
-    toRlpInteger(chainId),
-    contractAddress,
-    toRlpInteger(nonce)
-  ]);
-
-  // Prepend 0x05 (EIP-7702 transaction type / magic byte)
-  const payload = new Uint8Array([0x05, ...getBytes(rlpEncoded)]);
-  const hash = keccak256(payload);
-
-  // Sign the hash directly (not EIP-191)
-  const sig = signer.signingKey.sign(hash);
-
-  return {
-    chainId: chainId.toString(),
+  chainId?: bigint,
+  nonce?: number,
+): Promise<Authorization> => {
+  // Use ethers 6.14.3+ native 7702 authorization signing
+  const authRequest = await signer.populateAuthorization({
     address: contractAddress,
-    nonce,
-    yParity: sig.yParity,
-    r: sig.r,
-    s: sig.s,
-  };
+    ...(chainId !== undefined && { chainId }),
+    ...(nonce !== undefined && { nonce: BigInt(nonce) }),
+  });
+  
+  return signer.authorize(authRequest);
 };
+
+

src/validation/relay-adapt-7702-validator.ts

@@ -1,37 +1,32 @@
-import { verifyMessage, getBytes, keccak256, AbiCoder, encodeRlp, toBeHex, recoverAddress } from 'ethers';
+import { verifyMessage, getBytes, keccak256, AbiCoder, encodeRlp, toBeHex, recoverAddress, Authorization } from 'ethers';
 import { TransactionStructV2 } from '../models/transaction-types';
 import { RelayAdapt7702 } from '../abi/typechain/RelayAdapt7702';
-import { EIP7702Authorization } from '../models/relay-adapt-types';
 import { ACTION_DATA_STRUCT_ABI, TRANSACTION_STRUCT_ABI } from '../transaction/relay-adapt-7702-signature';
 
 export class RelayAdapt7702Validator {
   static validateAuthorization(
-    authorization: EIP7702Authorization,
+    authorization: Authorization,
     expectedContractAddress: string,
     expectedChainId: number
   ): string {
     if (authorization.address.toLowerCase() !== expectedContractAddress.toLowerCase()) {
       throw new Error('Authorization contract address mismatch');
     }
-    if (BigInt(authorization.chainId) !== BigInt(expectedChainId)) {
+    if (authorization.chainId !== BigInt(expectedChainId)) {
       throw new Error('Authorization chain ID mismatch');
     }
 
     // Reconstruct payload
     const rlpEncoded = encodeRlp([
-      authorization.chainId === '0' ? new Uint8Array(0) : toBeHex(BigInt(authorization.chainId)),
+      authorization.chainId === 0n ? new Uint8Array(0) : toBeHex(authorization.chainId),
       authorization.address,
-      authorization.nonce === 0 ? new Uint8Array(0) : toBeHex(authorization.nonce)
+      authorization.nonce === 0n ? new Uint8Array(0) : toBeHex(authorization.nonce)
     ]);
     const payload = new Uint8Array([0x05, ...getBytes(rlpEncoded)]);
     const hash = keccak256(payload);
 
     // Recover address
-    return recoverAddress(hash, {
-      r: authorization.r,
-      s: authorization.s,
-      yParity: authorization.yParity
-    });
+    return recoverAddress(hash, authorization.signature);
   }
 
   static validateExecution(

src/wallet/railgun-wallet.ts

@@ -10,9 +10,8 @@ import { Mnemonic } from '../key-derivation/bip39';
 import { PublicInputsRailgun } from '../models';
 import { signEDDSA } from '../utils/keys-utils';
 import { Prover } from '../prover/prover';
-import { HDNodeWallet } from 'ethers';
+import { HDNodeWallet, Authorization } from 'ethers';
 import { RelayAdapt7702Helper } from '../contracts/relay-adapt/relay-adapt-7702-helper';
-import { EIP7702Authorization } from '../models/relay-adapt-types';
 import { TransactionStructV2, TransactionStructV3 } from '../models/transaction-types';
 import { RelayAdapt } from '../abi/typechain/RelayAdapt';
 
@@ -88,15 +87,15 @@ class RailgunWallet extends AbstractWallet {
    * @param {bigint} chainId - Chain ID
    * @param {(TransactionStructV2 | TransactionStructV3)[]} transactions - Railgun transactions
    * @param {RelayAdapt.ActionDataStruct} actionData - Action Data
-   * @returns {Promise<{ authorization: EIP7702Authorization; signature: string }>}
+   * @returns {Promise<{ authorization: Authorization; signature: string }>}
    */
   async sign7702Request(
     encryptionKey: string,
     contractAddress: string,
     chainId: bigint,
     transactions: (TransactionStructV2 | TransactionStructV3)[],
     actionData: RelayAdapt.ActionDataStruct,
-  ): Promise<{ authorization: EIP7702Authorization; signature: string }> {
+  ): Promise<{ authorization: Authorization; signature: string }> {
     const index = await this.getEphemeralKeyIndex();
     const ephemeralWallet = await this.getEphemeralWallet(encryptionKey, index);