diff --git a/.changeset/clever-mice-laugh.md b/.changeset/clever-mice-laugh.md new file mode 100644 index 0000000000..3fc3974637 --- /dev/null +++ b/.changeset/clever-mice-laugh.md @@ -0,0 +1,9 @@ +--- +"viem": minor +--- + +Stabilized EIP-7702. + +- Added `prepareAuthorization` and `signAuthorization` Actions to the Wallet Client. +- Added `hashAuthorization`, `recoverAuthorizationAddress`, and `verifyAuthorization` Utilities. +- Renamed `account.experimental_signAuthorization` to `account.signAuthorization`. diff --git a/.changeset/dirty-trees-pay.md b/.changeset/dirty-trees-pay.md new file mode 100644 index 0000000000..9eed587648 --- /dev/null +++ b/.changeset/dirty-trees-pay.md @@ -0,0 +1,5 @@ +--- +"viem": minor +--- + +**BREAKING (Experimental)**: Removed deprecated `walletActionsEip5792` export. Use `eip5792Actions` instead. \ No newline at end of file diff --git a/.changeset/mighty-maps-dress.md b/.changeset/mighty-maps-dress.md new file mode 100644 index 0000000000..3641941e7f --- /dev/null +++ b/.changeset/mighty-maps-dress.md @@ -0,0 +1,5 @@ +--- +"viem": patch +--- + +**BREAKING (Experimental)**: Removed deprecated ERC-6492 exports in `viem/experimental`. These are no longer experimental. Use exports from `viem` instead. diff --git a/.changeset/new-seas-wash.md b/.changeset/new-seas-wash.md new file mode 100644 index 0000000000..96cf93ffd3 --- /dev/null +++ b/.changeset/new-seas-wash.md @@ -0,0 +1,5 @@ +--- +"viem": patch +--- + +**BREAKING (Experimental)**: Removed deprecated `walletActionsErc7715` export. Use `erc7715Actions` instead. diff --git a/.changeset/odd-parents-crash.md b/.changeset/odd-parents-crash.md new file mode 100644 index 0000000000..646f3d2741 --- /dev/null +++ b/.changeset/odd-parents-crash.md @@ -0,0 +1,44 @@ +--- +"viem": minor +--- + +**BREAKING (Experimental)**: + +Removed EIP-7702 exports in `viem/experimental`. These are no longer experimental. Use exports from `viem` or `viem/utils` instead. + +Note, there is also a behavioral change in the stable EIP-7702 `signAuthorization` function. Previously, it was assumed that the signer of the Authorization was also the executor of the Transaction. This is no longer the case. + +If the signer of the Authorization is **NOT** the executor of the Transaction, you no longer need to pass a `sponsor` parameter. + +```diff +const eoa = privateKeyToAccount('0x...') +const relay = privateKeyToAccount('0x...') + +const authorization = await client.signAuthorization({ + account: eoa, + contractAddress: '0x...', +- sponsor: true +}) + +const transaction = await client.sendTransaction({ + account: relay, + authorizationList: [authorization], +}) +``` + +If the signer of the Authorization is **ALSO** the executor of the Transaction, you will now need to pass the `executor` parameter with a value of `'self'`. + +```diff +const eoa = privateKeyToAccount('0x...') + +const authorization = await client.signAuthorization({ + account: eoa, + contractAddress: '0x...', ++ executor: 'self', +}) + +const transaction = await client.sendTransaction({ + account: eoa, + authorizationList: [authorization], +}) +``` diff --git a/package.json b/package.json index 74f787cdb6..44dadd141e 100644 --- a/package.json +++ b/package.json @@ -116,7 +116,7 @@ { "name": "const viem = require('viem') (cjs)", "path": "./src/_cjs/index.js", - "limit": "83 kB" + "limit": "84 kB" }, { "name": "import { createClient, http } from 'viem'", diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index caec1b5ea2..a7a1bbc087 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -3267,7 +3267,6 @@ packages: bun@1.1.30: resolution: {integrity: sha512-ysRL1pq10Xba0jqVLPrKU3YIv0ohfp3cTajCPtpjCyppbn3lfiAVNpGoHfyaxS17OlPmWmR67UZRPw/EueQuug==} - cpu: [arm64, x64] os: [darwin, linux, win32] hasBin: true diff --git a/site/pages/docs/accounts/local/signTransaction.md b/site/pages/docs/accounts/local/signTransaction.md index 3067a55dbf..82cc407c04 100644 --- a/site/pages/docs/accounts/local/signTransaction.md +++ b/site/pages/docs/accounts/local/signTransaction.md @@ -96,7 +96,7 @@ Signed EIP-7702 Authorization list. import { privateKeyToAccount } from 'viem/accounts' const account = privateKeyToAccount('0x...') // ---cut--- -const authorization = await account.experimental_signAuthorization({ +const authorization = await account.signAuthorization({ contractAddress: '0x...', chainId: 1, nonce: 1, diff --git a/site/pages/docs/actions/wallet/prepareTransactionRequest.md b/site/pages/docs/actions/wallet/prepareTransactionRequest.md index 817061595c..163311289a 100644 --- a/site/pages/docs/actions/wallet/prepareTransactionRequest.md +++ b/site/pages/docs/actions/wallet/prepareTransactionRequest.md @@ -208,8 +208,8 @@ const request = await walletClient.prepareTransactionRequest({ :::note **References** -- [EIP-7702 Overview](/experimental/eip7702) -- [`signAuthorization` Docs](/experimental/eip7702/signAuthorization) +- [EIP-7702 Overview](/docs/eip7702) +- [`signAuthorization` Docs](/docs/eip7702/signAuthorization) ::: ### blobs (optional) diff --git a/site/pages/docs/actions/wallet/sendTransaction.md b/site/pages/docs/actions/wallet/sendTransaction.md index 868198ed37..c9977e4f1b 100644 --- a/site/pages/docs/actions/wallet/sendTransaction.md +++ b/site/pages/docs/actions/wallet/sendTransaction.md @@ -178,8 +178,8 @@ const hash = await walletClient.sendTransaction({ :::note **References** -- [EIP-7702 Overview](/experimental/eip7702) -- [`signAuthorization` Docs](/experimental/eip7702/signAuthorization) +- [EIP-7702 Overview](/docs/eip7702) +- [`signAuthorization` Docs](/docs/eip7702/signAuthorization) ::: ### blobs (optional) diff --git a/site/pages/docs/actions/wallet/signTransaction.md b/site/pages/docs/actions/wallet/signTransaction.md index ec41d69311..f9e4a6d930 100644 --- a/site/pages/docs/actions/wallet/signTransaction.md +++ b/site/pages/docs/actions/wallet/signTransaction.md @@ -186,8 +186,8 @@ const signature = await walletClient.signTransaction({ :::note **References** -- [EIP-7702 Overview](/experimental/eip7702) -- [`signAuthorization` Docs](/experimental/eip7702/signAuthorization) +- [EIP-7702 Overview](/docs/eip7702) +- [`signAuthorization` Docs](/docs/eip7702/signAuthorization) ::: ### blobs (optional) diff --git a/site/pages/docs/contract/simulateContract.md b/site/pages/docs/contract/simulateContract.md index dcf27a9345..3de4fe58e4 100644 --- a/site/pages/docs/contract/simulateContract.md +++ b/site/pages/docs/contract/simulateContract.md @@ -462,8 +462,8 @@ const { result } = await publicClient.simulateContract({ :::note **References** -- [EIP-7702 Overview](/experimental/eip7702) -- [`signAuthorization` Docs](/experimental/eip7702/signAuthorization) +- [EIP-7702 Overview](/docs/eip7702) +- [`signAuthorization` Docs](/docs/eip7702/signAuthorization) ::: ### args (optional) diff --git a/site/pages/docs/contract/writeContract.md b/site/pages/docs/contract/writeContract.md index fcccc8f0fc..e35b7d0315 100644 --- a/site/pages/docs/contract/writeContract.md +++ b/site/pages/docs/contract/writeContract.md @@ -305,8 +305,8 @@ await walletClient.writeContract({ :::note **References** -- [EIP-7702 Overview](/experimental/eip7702) -- [`signAuthorization` Docs](/experimental/eip7702/signAuthorization) +- [EIP-7702 Overview](/docs/eip7702) +- [`signAuthorization` Docs](/docs/eip7702/signAuthorization) ::: ### args (optional) diff --git a/site/pages/experimental/eip7702.mdx b/site/pages/docs/eip7702.mdx similarity index 64% rename from site/pages/experimental/eip7702.mdx rename to site/pages/docs/eip7702.mdx index 4373aae377..fb8de7855c 100644 --- a/site/pages/experimental/eip7702.mdx +++ b/site/pages/docs/eip7702.mdx @@ -6,20 +6,19 @@ description: An Overview of EIP-7702 EIP-7702 is a proposal to add a new Transaction type to allow an EOA to designate a Smart Contract as its "implementation". -The main difference between an EIP-7702 Transaction and other transactions is the inclusion of a **"authorization list"** property, a set of `(chain_id, contract_address, nonce, y_parity, r, s)` tuples that depict what Contract bytecode(s) should be injected onto the Externally Owned Account during execution. +The main difference between an EIP-7702 Transaction and other transactions is the inclusion of a **"authorization list"** property, a set of `(chain_id, contract_address, nonce, y_parity, r, s)` tuples that depict what Contracts should be delegated onto the Externally Owned Account. :::note -In Viem, you won't need to worry about constructing these Authorization Tuples manually as you can use [`signAuthorization`](/experimental/eip7702/signAuthorization) to generate them and use them in [Transaction APIs](/experimental/eip7702/contract-writes). +In Viem, you won't need to worry about constructing these Authorization Tuples manually as you can use [`signAuthorization`](/docs/eip7702/signAuthorization) to generate them and use them in [Transaction APIs](/docs/eip7702/contract-writes). ::: Applications of EIP-7702 include: -- **Batching**: allowing multiple operations from the same user in one atomic transaction. One common example is an ERC-20 approval followed by spending that approval, a common workflow in DEXes that requires two transactions today. Advanced use cases of batching occasionally involve dependencies: the output of the first operation is part of the input to the second operation. [Example](/experimental/eip7702/contract-writes#5-invoke-contract-function) -- **Sponsorship**: account X pays for a transaction on behalf of account Y. Account X could be paid in some other ERC-20 for this service, or it could be an application operator including the transactions of its users for free. [Example](/experimental/eip7702/contract-writes#6-optional-use-a-sponsor) +- **Batching**: allowing multiple operations from the same user in one atomic transaction. One common example is an ERC-20 approval followed by spending that approval, a common workflow in DEXes that requires two transactions today. Advanced use cases of batching occasionally involve dependencies: the output of the first operation is part of the input to the second operation. +- **Sponsorship**: account X pays for a transaction on behalf of account Y. Account X could be paid in some other ERC-20 for this service, or it could be an application operator including the transactions of its users for free. - **Privilege de-escalation**: users can sign sub-keys, and give them specific permissions that are much weaker than global access to the account. For example, you could imagine a permission to spend ERC-20 tokens but not ETH, or to spend up to 1% of total balance per day, or to interact only with a specific application. ## Next Steps -- [Extending Client with EIP-7702](/experimental/eip7702/client) -- [Contract Writes](/experimental/eip7702/contract-writes) -- [Sending Transactions](/experimental/eip7702/sending-transactions) \ No newline at end of file +- [Contract Writes](/docs/eip7702/contract-writes) +- [Sending Transactions](/docs/eip7702/sending-transactions) \ No newline at end of file diff --git a/site/pages/docs/eip7702/contract-writes.md b/site/pages/docs/eip7702/contract-writes.md new file mode 100644 index 0000000000..82daadc1bf --- /dev/null +++ b/site/pages/docs/eip7702/contract-writes.md @@ -0,0 +1,388 @@ +# Contract Writes with EIP-7702 + +The guide below demonstrates how to perform Contract Writes with EIP-7702 to invoke Contract functions on an Externally Owned Account (EOA). + +## Overview + +Here is an end-to-end overview of how to perform a Contract Write to send a batch of Calls. We will break it down into [Steps](#steps) below. + +:::code-group + +```ts twoslash [example.ts] +import { privateKeyToAccount } from 'viem/accounts' +import { walletClient } from './config' +import { abi, contractAddress } from './contract' + +const eoa = privateKeyToAccount('0x...') + +// 1. Authorize designation of the Contract onto the EOA. +const authorization = await walletClient.signAuthorization({ + account: eoa, + contractAddress, +}) + +// 2. Designate the Contract on the EOA, and invoke the +// `initialize` function. +const hash = await walletClient.writeContract({ + abi, + address: eoa.address, + authorizationList: [authorization], + // ↑ 3. Pass the Authorization as a parameter. + functionName: 'initialize', +}) +``` + +```ts twoslash [config.ts] filename="config.ts" +import { createWalletClient, http } from 'viem' +import { sepolia } from 'viem/chains' +import { privateKeyToAccount } from 'viem/accounts' + +export const relay = privateKeyToAccount('0x...') + +export const walletClient = createWalletClient({ + account: relay, + chain: sepolia, + transport: http(), +}) +``` + +```ts twoslash [contract.ts] filename="contract.ts" +export const abi = [ + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "ping", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, +] as const + +export const contractAddress = '0x...' +``` + +```solidity [Delegation.sol] +pragma solidity ^0.8.20; + +contract Delegation { + event Log(string message); + + function initialize() external payable { + emit Log('Hello, world!'); + } + + function ping() external pure { + emit Log('Pong!'); + } +} +``` + +::: + +## Steps + +### 1. Set up Smart Contract + +We will need to set up a Smart Contract to designate on the Account. For the purposes of this guide, we will [create](https://book.getfoundry.sh/reference/forge/forge-init) and [deploy](https://book.getfoundry.sh/forge/deploying) a simple demonstration `Delegation.sol` contract, however, you can use any existing deployed contract. + +Firstly, [deploy a Contract](https://book.getfoundry.sh/forge/deploying) to the Network with the following source: + +```solidity [Delegation.sol] +pragma solidity ^0.8.20; + +contract Delegation { + event Log(string message); + + function initialize() external payable { + emit Log('Hello, world!'); + } + + function ping() external pure { + emit Log('Pong!'); + } +} +``` + +### 2. Set up Client & Account + +Next, we will need to set up a Client and a "Relay Account" that will be responsible for executing the EIP-7702 Contract Write. + +```ts twoslash [config.ts] +import { createWalletClient, http } from 'viem' +import { sepolia } from 'viem/chains' +import { privateKeyToAccount } from 'viem/accounts' + +export const relay = privateKeyToAccount('0x...') + +export const walletClient = createWalletClient({ + account: relay, + chain: sepolia, + transport: http(), +}) +``` + +:::info + +In this demo, we will be using a "Relay Account" (not the EOA) to execute the Transaction. This is typically how EIP-7702 is used in practice, as the relayer can sponsor the gas fees to perform the Transaction. + +However, it is also possible for the EOA to sign and also execute the Transaction. [See more](#note-self-executing-eip-7702). +::: + +### 3. Authorize Contract Designation + +We will need to sign an Authorization to designate the Contract to the Account. + +In the example below, we are instantiating an existing EOA (`account`) and using it to sign the Authorization – this will be the Account that will be used for delegation. + +:::code-group + +```ts twoslash [example.ts] +import { walletClient } from './config' +import { contractAddress } from './contract' + +const eoa = privateKeyToAccount('0x...') // [!code focus] + +const authorization = await walletClient.signAuthorization({ // [!code focus] + account: eoa, // [!code focus] + contractAddress, // [!code focus] +}) // [!code focus] +``` + +```ts twoslash [contract.ts] filename="contract.ts" +export const abi = [ + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "ping", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, +] as const + +export const contractAddress = '0x...' +``` + +```ts twoslash [config.ts] +import { createWalletClient, http } from 'viem' +import { sepolia } from 'viem/chains' +import { privateKeyToAccount } from 'viem/accounts' + +export const relay = privateKeyToAccount('0x...') + +export const walletClient = createWalletClient({ + account: relay, + chain: sepolia, + transport: http(), +}) +``` + +::: + +:::info +If the EOA is also executing the Transaction, you will need to pass `executor: 'self'` to `signAuthorization`. [See more](#note-self-executing-eip-7702). +::: + +### 4. Execute Contract Write + +We can now designate the Contract on the Account (and execute the `initialize` function) by sending an EIP-7702 Contract Write. + +:::code-group + +```ts twoslash [example.ts] +import { walletClient } from './config' +import { abi, contractAddress } from './contract' + +const eoa = privateKeyToAccount('0x...') + +const authorization = await walletClient.signAuthorization({ + account: eoa, + contractAddress, +}) + +const hash = await walletClient.writeContract({ // [!code focus] + abi, // [!code focus] + address: eoa.address, // [!code focus] + authorizationList: [authorization], // [!code focus] + functionName: 'initialize', // [!code focus] +}) // [!code focus] +``` + +```ts twoslash [contract.ts] filename="contract.ts" +export const abi = [ + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "ping", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, +] as const + +export const contractAddress = '0x...' +``` + +```ts twoslash [config.ts] +import { createWalletClient, http } from 'viem' +import { sepolia } from 'viem/chains' +import { privateKeyToAccount } from 'viem/accounts' + +export const relay = privateKeyToAccount('0x...') + +export const walletClient = createWalletClient({ + account: relay, + chain: sepolia, + transport: http(), +}) +``` + +::: + +### 5. (Optional) Interact with the Delegated Account + +Now that we have designated a Contract onto the Account, we can interact with it by invoking its functions. + +Note that we no longer need to use an Authorization! + +:::code-group + +```ts twoslash [example.ts] +import { walletClient } from './config' +import { abi } from './contract' + +const eoa = privateKeyToAccount('0x...') + +const hash = await walletClient.writeContract({ + abi, + address: eoa.address, + functionName: 'ping', // [!code hl] +}) +``` + +```ts twoslash [contract.ts] filename="contract.ts" +export const abi = [ + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "ping", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, +] as const + +export const contractAddress = '0x...' +``` + +```ts twoslash [config.ts] +import { createWalletClient, http } from 'viem' +import { sepolia } from 'viem/chains' +import { privateKeyToAccount } from 'viem/accounts' + +export const relay = privateKeyToAccount('0x...') + +export const walletClient = createWalletClient({ + account: relay, + chain: sepolia, + transport: http(), +}) +``` + +::: + + +### Note: Self-executing EIP-7702 + +If the signer of the Authorization (ie. the EOA) is also executing the Transaction, you will need to pass `executor: 'self'` to `signAuthorization`. + +This is because `authorization.nonce` must be incremented by 1 over `transaction.nonce`, so we will need to hint to `signAuthorization` that this is the case. + +:::tip +In the example below, we are attaching an EOA to the Wallet Client (see `config.ts`), and using it for signing the Authorization and executing the Transaction. +::: + +:::code-group + +```ts twoslash [example.ts] +import { walletClient } from './config' +import { abi, contractAddress } from './contract' + +const authorization = await walletClient.signAuthorization({ + account: eoa, // [!code --] + contractAddress, + executor: 'self', // [!code ++] +}) + +const hash = await walletClient.writeContract({ + abi, + address: eoa.address, // [!code --] + address: walletClient.account.address, // [!code ++] + authorizationList: [authorization], + functionName: 'initialize', +}) +``` + +```ts twoslash [config.ts] +// @noErrors +import { createWalletClient, http } from 'viem' +import { sepolia } from 'viem/chains' +import { privateKeyToAccount } from 'viem/accounts' + +export const relay = privateKeyToAccount('0x...') // [!code --] +export const eoa = privateKeyToAccount('0x...') // [!code ++] + +export const walletClient = createWalletClient({ + account: relay, // [!code --] + account: eoa, // [!code ++] + chain: sepolia, + transport: http(), +}) +``` + +```ts twoslash [contract.ts] filename="contract.ts" +export const abi = [ + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "ping", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, +] as const + +export const contractAddress = '0x...' +``` + +::: diff --git a/site/pages/experimental/eip7702/hashAuthorization.md b/site/pages/docs/eip7702/hashAuthorization.md similarity index 82% rename from site/pages/experimental/eip7702/hashAuthorization.md rename to site/pages/docs/eip7702/hashAuthorization.md index d3724e0837..46fb600d6b 100644 --- a/site/pages/experimental/eip7702/hashAuthorization.md +++ b/site/pages/docs/eip7702/hashAuthorization.md @@ -9,13 +9,13 @@ Calculates an Authorization hash in [EIP-7702 format](https://eips.ethereum.org/ ## Import ```ts twoslash -import { hashAuthorization } from 'viem/experimental' +import { hashAuthorization } from 'viem/utils' ``` ## Usage ```ts twoslash -import { hashAuthorization } from 'viem/experimental' +import { hashAuthorization } from 'viem/utils' hashAuthorization({ contractAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045', @@ -40,7 +40,7 @@ The hashed Authorization. Address of the contract to set as code for the Authority. ```ts twoslash -import { hashAuthorization } from 'viem/experimental' +import { hashAuthorization } from 'viem/utils' hashAuthorization({ contractAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045', // [!code focus] @@ -56,7 +56,7 @@ hashAuthorization({ Chain ID to authorize. ```ts twoslash -import { hashAuthorization } from 'viem/experimental' +import { hashAuthorization } from 'viem/utils' hashAuthorization({ contractAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045', @@ -72,7 +72,7 @@ hashAuthorization({ Nonce of the Authority to authorize. ```ts twoslash -import { hashAuthorization } from 'viem/experimental' +import { hashAuthorization } from 'viem/utils' hashAuthorization({ contractAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045', @@ -89,7 +89,7 @@ hashAuthorization({ Output format. ```ts twoslash -import { hashAuthorization } from 'viem/experimental' +import { hashAuthorization } from 'viem/utils' hashAuthorization({ contractAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045', diff --git a/site/pages/experimental/eip7702/prepareAuthorization.md b/site/pages/docs/eip7702/prepareAuthorization.md similarity index 90% rename from site/pages/experimental/eip7702/prepareAuthorization.md rename to site/pages/docs/eip7702/prepareAuthorization.md index 48b888cf9e..320513ec07 100644 --- a/site/pages/experimental/eip7702/prepareAuthorization.md +++ b/site/pages/docs/eip7702/prepareAuthorization.md @@ -7,7 +7,7 @@ description: Prepares an EIP-7702 Authorization for signing. Prepares an [EIP-7702 Authorization](https://eips.ethereum.org/EIPS/eip-7702) for signing. This Action will fill the required fields of the Authorization object if they are not provided (e.g. `nonce` and `chainId`). -With the prepared Authorization object, you can use [`signAuthorization`](/experimental/eip7702/signAuthorization) to sign over it. +With the prepared Authorization object, you can use [`signAuthorization`](/docs/eip7702/signAuthorization) to sign over it. ## Usage @@ -32,13 +32,12 @@ const signedAuthorization = await walletClient.signAuthorization(authorization) import { createWalletClient, http } from 'viem' import { privateKeyToAccount } from 'viem/accounts' import { mainnet } from 'viem/chains' -import { eip7702Actions } from 'viem/experimental' export const walletClient = createWalletClient({ account: privateKeyToAccount('0x...'), chain: mainnet, transport: http(), -}).extend(eip7702Actions()) +}) ``` ::: @@ -69,13 +68,12 @@ const signedAuthorization = await walletClient.signAuthorization(authorization) import { createWalletClient, http } from 'viem' import { privateKeyToAccount } from 'viem/accounts' import { mainnet } from 'viem/chains' -import { eip7702Actions } from 'viem/experimental' export const walletClient = createWalletClient({ account: privateKeyToAccount('0x...'), chain: mainnet, transport: http(), -}).extend(eip7702Actions()) +}) ``` ::: @@ -141,13 +139,13 @@ const authorization = await walletClient.prepareAuthorization({ }) ``` -### sponsor (optional) +### executor (optional) -- **Type:** `true | Address | Account` +- **Type:** `'self' | undefined` -Whether the EIP-7702 Transaction will be executed by another Account. +Whether the EIP-7702 Transaction will be executed by the Account that signed the Authorization. -If not specified, it will be assumed that the EIP-7702 Transaction will be executed by the Account that signed the Authorization. +If not specified, it will be assumed that the EIP-7702 Transaction will be executed by another Account (ie. a relayer Account). ```ts twoslash import { privateKeyToAccount } from 'viem/accounts' @@ -156,7 +154,7 @@ import { walletClient } from './client' const authorization = await walletClient.prepareAuthorization({ account: privateKeyToAccount('0x...'), contractAddress: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2', - sponsor: true, // [!code focus] + executor: 'self', // [!code focus] }) ``` diff --git a/site/pages/experimental/eip7702/recoverAuthorizationAddress.md b/site/pages/docs/eip7702/recoverAuthorizationAddress.md similarity index 83% rename from site/pages/experimental/eip7702/recoverAuthorizationAddress.md rename to site/pages/docs/eip7702/recoverAuthorizationAddress.md index b107855134..fccfdd5a33 100644 --- a/site/pages/experimental/eip7702/recoverAuthorizationAddress.md +++ b/site/pages/docs/eip7702/recoverAuthorizationAddress.md @@ -9,7 +9,7 @@ Recovers the original signing address from a signed Authorization object. ## Import ```ts twoslash -import { recoverAuthorizationAddress } from 'viem/experimental' +import { recoverAuthorizationAddress } from 'viem/utils' ``` ## Usage @@ -17,10 +17,14 @@ import { recoverAuthorizationAddress } from 'viem/experimental' :::code-group ```ts twoslash [example.ts] -import { recoverAuthorizationAddress } from 'viem/experimental' // [!code focus] +import { privateKeyToAccount } from 'viem/accounts' +import { recoverAuthorizationAddress } from 'viem/utils' // [!code focus] import { walletClient } from './client' +const eoa = privateKeyToAccount('0x...') + const authorization = await walletClient.signAuthorization({ + account: eoa, authorization: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2' }) @@ -31,15 +35,12 @@ const address = await recoverAuthorizationAddress({ // [!code focus] ```ts twoslash [client.ts] filename="client.ts" import { createWalletClient, http } from 'viem' -import { privateKeyToAccount } from 'viem/accounts' import { mainnet } from 'viem/chains' -import { eip7702Actions } from 'viem/experimental' export const walletClient = createWalletClient({ - account: privateKeyToAccount('0x...'), chain: mainnet, transport: http(), -}).extend(eip7702Actions()) +}) ``` ::: @@ -59,7 +60,7 @@ The address that signed the Authorization object. The Authorization object that was signed. ```ts twoslash -import { recoverAuthorizationAddress } from 'viem/experimental' +import { recoverAuthorizationAddress } from 'viem/utils' import { walletClient } from './client' // ---cut--- const authorization = await walletClient.signAuthorization({ @@ -77,7 +78,7 @@ const address = await recoverAuthorizationAddress({ The signature that was generated by signing the Authorization object with the address's private key. ```ts twoslash -import { recoverAuthorizationAddress } from 'viem/experimental' +import { recoverAuthorizationAddress } from 'viem/utils' import { walletClient } from './client' // ---cut--- const signature = await walletClient.signAuthorization({ diff --git a/site/pages/docs/eip7702/sending-transactions.md b/site/pages/docs/eip7702/sending-transactions.md new file mode 100644 index 0000000000..3e4c0047f6 --- /dev/null +++ b/site/pages/docs/eip7702/sending-transactions.md @@ -0,0 +1,400 @@ +# Sending Transactions with EIP-7702 + +The guide below demonstrates how to send EIP-7702 Transactions to invoke Contract functions on an Externally Owned Account (EOA). + +## Overview + +Here is an end-to-end overview of how to execute an EIP-7702 Transaction to emit a simple event on the EOA's designated contract. We will break it down into [Steps](#steps) below. + +:::code-group + +```ts twoslash [example.ts] +import { encodeFunctionData } from 'viem' +import { privateKeyToAccount } from 'viem/accounts' +import { walletClient } from './config' +import { abi, contractAddress } from './contract' + +const eoa = privateKeyToAccount('0x...') + +// 1. Authorize designation of the Contract onto the EOA. +const authorization = await walletClient.signAuthorization({ + account: eoa, + contractAddress, +}) + +// 2. Designate the Contract on the EOA, and invoke the +// `initialize` function. +const hash = await walletClient.sendTransaction({ + authorizationList: [authorization], + // ↑ 3. Pass the Authorization as a parameter. + data: encodeFunctionData({ + abi, + functionName: 'initialize', + }), + to: eoa.address, +}) +``` + +```ts twoslash [config.ts] filename="config.ts" +import { createWalletClient, http } from 'viem' +import { sepolia } from 'viem/chains' +import { privateKeyToAccount } from 'viem/accounts' + +export const relay = privateKeyToAccount('0x...') + +export const walletClient = createWalletClient({ + account: relay, + chain: sepolia, + transport: http(), +}) +``` + +```ts twoslash [contract.ts] filename="contract.ts" +export const abi = [ + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "ping", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, +] as const + +export const contractAddress = '0x...' +``` + +```solidity [Delegation.sol] +pragma solidity ^0.8.20; + +contract Delegation { + event Log(string message); + + function initialize() external payable { + emit Log('Hello, world!'); + } + + function ping() external pure { + emit Log('Pong!'); + } +} +``` + +::: + +## Steps + +### 1. Set up Smart Contract + +We will need to set up a Smart Contract to designate on the Account. For the purposes of this guide, we will [create](https://book.getfoundry.sh/reference/forge/forge-init) and [deploy](https://book.getfoundry.sh/forge/deploying) a simple demonstration `Delegation.sol` contract, however, you can use any existing deployed contract. + +Firstly, [deploy a Contract](https://book.getfoundry.sh/forge/deploying) to the Network with the following source: + +```solidity [Delegation.sol] +pragma solidity ^0.8.20; + +contract Delegation { + event Log(string message); + + function initialize() external payable { + emit Log('Hello, world!'); + } + + + function ping() external pure { + emit Log('Pong!'); + } +} +``` + +### 2. Set up Client & Account + +Next, we will need to set up a Client and a "Relay Account" that will be responsible for executing the EIP-7702 Transaction. + +```ts twoslash [config.ts] +import { createWalletClient, http } from 'viem' +import { sepolia } from 'viem/chains' +import { privateKeyToAccount } from 'viem/accounts' + +export const relay = privateKeyToAccount('0x...') + +export const walletClient = createWalletClient({ + account: relay, + chain: sepolia, + transport: http(), +}) +``` + +:::info + +In this demo, we will be using a "Relay Account" (not the EOA) to execute the Transaction. This is typically how EIP-7702 is used in practice, as the relayer can sponsor the gas fees to perform the Transaction. + +However, it is also possible for the EOA to sign and also execute the Transaction. [See more](#note-self-executing-eip-7702). +::: + +### 3. Authorize Contract Designation + +We will need to sign an Authorization to designate the Contract to the Account. + +In the example below, we are instantiating an existing EOA (`account`) and using it to sign the Authorization – this will be the Account that will be used for delegation. + +:::code-group + +```ts twoslash [example.ts] +import { walletClient } from './config' +import { contractAddress } from './contract' + +const eoa = privateKeyToAccount('0x...') // [!code focus] + +const authorization = await walletClient.signAuthorization({ // [!code focus] + account: eoa, // [!code focus] + contractAddress, // [!code focus] +}) // [!code focus] +``` + +```ts twoslash [contract.ts] filename="contract.ts" +export const abi = [ + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "ping", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, +] as const + +export const contractAddress = '0x...' +``` + +```ts twoslash [config.ts] +import { createWalletClient, http } from 'viem' +import { sepolia } from 'viem/chains' +import { privateKeyToAccount } from 'viem/accounts' + +export const relay = privateKeyToAccount('0x...') + +export const walletClient = createWalletClient({ + account: relay, + chain: sepolia, + transport: http(), +}) +``` + +::: + +:::info +If the EOA is also executing the Transaction, you will need to pass `executor: 'self'` to `signAuthorization`. [See more](#note-self-executing-eip-7702). +::: + + +### 4. Execute Transaction + +We can now designate the Contract on the Account (and execute the `initialize` function) by sending an EIP-7702 Transaction. + +:::code-group + +```ts twoslash [example.ts] +import { encodeFunctionData } from 'viem' +import { walletClient } from './config' +import { contractAddress } from './contract' + +const eoa = privateKeyToAccount('0x...') + +const authorization = await walletClient.signAuthorization({ + account: eoa, + contractAddress, +}) + +const hash = await walletClient.sendTransaction({ // [!code focus] + authorizationList: [authorization], // [!code focus] + data: encodeFunctionData({ // [!code focus] + abi, // [!code focus] + functionName: 'initialize', // [!code focus] + }), // [!code focus] + to: eoa.address, // [!code focus] +}) // [!code focus] +``` + +```ts twoslash [contract.ts] filename="contract.ts" +export const abi = [ + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "ping", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, +] as const + +export const contractAddress = '0x...' +``` + +```ts twoslash [config.ts] +import { createWalletClient, http } from 'viem' +import { sepolia } from 'viem/chains' +import { privateKeyToAccount } from 'viem/accounts' + +export const relay = privateKeyToAccount('0x...') + +export const walletClient = createWalletClient({ + account: relay, + chain: sepolia, + transport: http(), +}) +``` + +::: + +### 5. (Optional) Interact with the Delegated Account + +Now that we have designated a Contract onto the Account, we can interact with it by invoking its functions. + +Note that we no longer need to use an Authorization! + +:::code-group + +```ts twoslash [example.ts] +import { encodeFunctionData } from 'viem' +import { walletClient } from './config' + +const eoa = privateKeyToAccount('0x...') + +const hash = await walletClient.sendTransaction({ + data: encodeFunctionData({ + abi, + functionName: 'ping', + }), + to: eoa.address, +}) +``` + +```ts twoslash [contract.ts] filename="contract.ts" +export const abi = [ + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "ping", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, +] as const + +export const contractAddress = '0x...' +``` + +```ts twoslash [config.ts] +import { createWalletClient, http } from 'viem' +import { sepolia } from 'viem/chains' +import { privateKeyToAccount } from 'viem/accounts' + +export const relay = privateKeyToAccount('0x...') + +export const walletClient = createWalletClient({ + account: relay, + chain: sepolia, + transport: http(), +}) +``` + +::: + +### Note: Self-executing EIP-7702 + +If the signer of the Authorization (ie. the EOA) is also executing the Transaction, you will need to pass `executor: 'self'` to `signAuthorization`. + +This is because `authorization.nonce` must be incremented by 1 over `transaction.nonce`, so we will need to hint to `signAuthorization` that this is the case. + +:::tip +In the example below, we are attaching an EOA to the Wallet Client (see `config.ts`), and using it for signing the Authorization and executing the Transaction. +::: + +:::code-group + +```ts twoslash [example.ts] +import { encodeFunctionData } from 'viem' +import { walletClient } from './config' +import { contractAddress } from './contract' + +const authorization = await walletClient.signAuthorization({ + account: eoa, // [!code --] + contractAddress, + executor: 'self', // [!code ++] +}) + +const hash = await walletClient.sendTransaction({ + authorizationList: [authorization], + data: encodeFunctionData({ + abi, + functionName: 'initialize', + }), + to: eoa.address, // [!code --] + to: walletClient.account.address, // [!code ++] +}) +``` + +```ts twoslash [config.ts] +// @noErrors +import { createWalletClient, http } from 'viem' +import { sepolia } from 'viem/chains' +import { privateKeyToAccount } from 'viem/accounts' + +export const relay = privateKeyToAccount('0x...') // [!code --] +export const eoa = privateKeyToAccount('0x...') // [!code ++] + +export const walletClient = createWalletClient({ + account: relay, // [!code --] + account: eoa, // [!code ++] + chain: sepolia, + transport: http(), +}) +``` + +```ts twoslash [contract.ts] filename="contract.ts" +export const abi = [ + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "ping", + "inputs": [], + "outputs": [], + "stateMutability": "pure" + }, +] as const + +export const contractAddress = '0x...' +``` + +::: \ No newline at end of file diff --git a/site/pages/experimental/eip7702/signAuthorization.md b/site/pages/docs/eip7702/signAuthorization.md similarity index 85% rename from site/pages/experimental/eip7702/signAuthorization.md rename to site/pages/docs/eip7702/signAuthorization.md index c783522998..9e2829d322 100644 --- a/site/pages/experimental/eip7702/signAuthorization.md +++ b/site/pages/docs/eip7702/signAuthorization.md @@ -4,7 +4,7 @@ description: Signs an EIP-7702 Authorization object. # signAuthorization -Signs an [EIP-7702 Authorization](https://eips.ethereum.org/EIPS/eip-7702). The signed Authorization can be used in Transaction APIs like [`sendTransaction`](/docs/actions/wallet/sendTransaction#authorizationlist-optional) and [`writeContract`](/docs/contract/writeContract#authorizationlist-optional) to inject the authorized Contract bytecode(s) into an Account at the time of execution. +Signs an [EIP-7702 Authorization](https://eips.ethereum.org/EIPS/eip-7702). The signed Authorization can be used in Transaction APIs like [`sendTransaction`](/docs/actions/wallet/sendTransaction#authorizationlist-optional) and [`writeContract`](/docs/contract/writeContract#authorizationlist-optional) to delegate an authorized Contract onto an Account. ## Usage @@ -13,9 +13,13 @@ A Contract can be authorized by supplying a `contractAddress`. By default, it wi :::code-group ```ts twoslash [example.ts] +import { privateKeyToAccount } from 'viem/accounts' import { walletClient } from './client' + +const eoa = privateKeyToAccount('0x...') const authorization = await walletClient.signAuthorization({ // [!code focus] + account: eoa, // [!code focus] contractAddress: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2', // [!code focus] }) // [!code focus] // @log: { @@ -30,7 +34,7 @@ const authorization = await walletClient.signAuthorization({ // [!code focus] const hash = await walletClient.sendTransaction({ authorizationList: [authorization], data: '0xdeadbeef', - to: walletClient.account.address, + to: eoa.address, }) ``` @@ -38,13 +42,14 @@ const hash = await walletClient.sendTransaction({ import { createWalletClient, http } from 'viem' import { privateKeyToAccount } from 'viem/accounts' import { mainnet } from 'viem/chains' -import { eip7702Actions } from 'viem/experimental' + +const relay = privateKeyToAccount('0x...') export const walletClient = createWalletClient({ - account: privateKeyToAccount('0x...'), + account: relay, chain: mainnet, transport: http(), -}).extend(eip7702Actions()) +}) ``` ::: @@ -57,8 +62,11 @@ We can explicitly sign over a provided `nonce` and/or `chainId` by supplying the ```ts twoslash [example.ts] import { walletClient } from './client' + +const eoa = privateKeyToAccount('0x...') const authorization = await walletClient.signAuthorization({ + account: eoa, contractAddress: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2', chainId: 10, // [!code focus] nonce: 420, // [!code focus] @@ -75,7 +83,7 @@ const authorization = await walletClient.signAuthorization({ const hash = await walletClient.sendTransaction({ authorizationList: [authorization], data: '0xdeadbeef', - to: walletClient.account.address, + to: eoa.address, }) ``` @@ -83,13 +91,14 @@ const hash = await walletClient.sendTransaction({ import { createWalletClient, http } from 'viem' import { privateKeyToAccount } from 'viem/accounts' import { mainnet } from 'viem/chains' -import { eip7702Actions } from 'viem/experimental' + +const relay = privateKeyToAccount('0x...') export const walletClient = createWalletClient({ - account: privateKeyToAccount('0x...'), + account: relay, chain: mainnet, transport: http(), -}).extend(eip7702Actions()) +}) ``` ::: @@ -106,7 +115,7 @@ A signed Authorization object. - **Type:** `Account` -Account to use to authorize injection of the [Contract (`authorization`)](#authorization) onto the Account. +Account to use for delegation. Accepts a [Local Account (Private Key, etc)](/docs/clients/wallet#local-accounts-private-key-mnemonic-etc). @@ -142,7 +151,7 @@ const authorization = await walletClient.signAuthorization({ - **Type:** `Address` -The target Contract to inject onto the Account. +The target Contract to delegate to the Account. ```ts twoslash import { privateKeyToAccount } from 'viem/accounts' @@ -154,13 +163,13 @@ const authorization = await walletClient.signAuthorization({ }) ``` -### sponsor (optional) +### executor (optional) -- **Type:** `true | Address | Account` +- **Type:** `'self' | undefined` -Whether the EIP-7702 Transaction will be executed by another Account. +Whether the EIP-7702 Transaction will be executed by the Account that signed the Authorization. -If not specified, it will be assumed that the EIP-7702 Transaction will be executed by the Account that signed the Authorization. +If not specified, it will be assumed that the EIP-7702 Transaction will be executed by another Account (ie. a relayer Account). ```ts twoslash import { privateKeyToAccount } from 'viem/accounts' @@ -169,7 +178,7 @@ import { walletClient } from './client' const authorization = await walletClient.signAuthorization({ account: privateKeyToAccount('0x...'), contractAddress: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2', - sponsor: true, // [!code focus] + executor: 'self', // [!code focus] }) ``` diff --git a/site/pages/experimental/eip7702/verifyAuthorization.md b/site/pages/docs/eip7702/verifyAuthorization.md similarity index 84% rename from site/pages/experimental/eip7702/verifyAuthorization.md rename to site/pages/docs/eip7702/verifyAuthorization.md index bd50e1acf3..b238905844 100644 --- a/site/pages/experimental/eip7702/verifyAuthorization.md +++ b/site/pages/docs/eip7702/verifyAuthorization.md @@ -9,7 +9,7 @@ Verifies that an Authorization object was signed by the provided address. ## Import ```ts twoslash -import { verifyAuthorization } from 'viem/experimental' +import { verifyAuthorization } from 'viem/utils' ``` ## Usage @@ -17,30 +17,31 @@ import { verifyAuthorization } from 'viem/experimental' :::code-group ```ts twoslash [example.ts] -import { verifyAuthorization } from 'viem/experimental' // [!code focus] +import { privateKeyToAccount } from 'viem/accounts' +import { verifyAuthorization } from 'viem/utils' // [!code focus] import { walletClient } from './client' +const eoa = privateKeyToAccount('0x...') + const authorization = await walletClient.signAuthorization({ + account: eoa, authorization: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2' }) const valid = await verifyAuthorization({ // [!code focus] - address: walletClient.account.address, // [!code focus] + address: eoa.address, // [!code focus] authorization, // [!code focus] }) // [!code focus] ``` ```ts twoslash [client.ts] filename="client.ts" import { createWalletClient, http } from 'viem' -import { privateKeyToAccount } from 'viem/accounts' import { mainnet } from 'viem/chains' -import { eip7702Actions } from 'viem/experimental' export const walletClient = createWalletClient({ - account: privateKeyToAccount('0x...'), chain: mainnet, transport: http(), -}).extend(eip7702Actions()) +}) ``` ::: @@ -60,7 +61,7 @@ Whether the signature is valid for the provided Authorization object. The address that signed the Authorization object. ```ts twoslash -import { verifyAuthorization } from 'viem/experimental' +import { verifyAuthorization } from 'viem/utils' import { walletClient } from './client' const authorization = await walletClient.signAuthorization({ @@ -80,7 +81,7 @@ const valid = await verifyAuthorization({ The Authorization object to be verified. ```ts twoslash -import { verifyAuthorization } from 'viem/experimental' +import { verifyAuthorization } from 'viem/utils' import { walletClient } from './client' // ---cut--- const authorization = await walletClient.signAuthorization({ @@ -100,7 +101,7 @@ const valid = await verifyAuthorization({ The signature that was generated by signing the Authorization object with the address's private key. ```ts twoslash -import { verifyAuthorization } from 'viem/experimental' +import { verifyAuthorization } from 'viem/utils' import { walletClient } from './client' // ---cut--- const signature = await walletClient.signAuthorization({ diff --git a/site/pages/experimental/eip7702/client.md b/site/pages/experimental/eip7702/client.md deleted file mode 100644 index 1019f72bdf..0000000000 --- a/site/pages/experimental/eip7702/client.md +++ /dev/null @@ -1,85 +0,0 @@ -# Extending Client with EIP-7702 [Setting up your Viem Client] - -To use the experimental functionality of EIP-7702, you must extend your existing (or new) Viem Client with experimental EIP-7702 Actions. - -## Overview - -Here is an end-to-end overview of how to extend a Viem Client with EIP-7702 Actions. We will break it down into Steps below. - -```ts twoslash -// @noErrors -import { createWalletClient, http } from 'viem' -import { anvil } from 'viem/chains' -import { eip7702Actions } from 'viem/experimental' - -const walletClient = createWalletClient({ - chain: anvil, - transport: http(), -}).extend(eip7702Actions()) - -const authorization = await walletClient.signAuthorization({/* ... */}) -``` - -:::warning -EIP-7702 is currently not supported on Ethereum Mainnet or Testnets. For this example, we are using the `anvil` chain which interfaces with an [Anvil node](https://book.getfoundry.sh/anvil/) (a local Ethereum network). -::: - -## Steps - -### 0. Install & Run Anvil - -EIP-7702 is currently not supported on Ethereum Mainnet or Testnets, so let's set up an EIP-7702 compatible network. We will use an [Anvil node](https://book.getfoundry.sh/anvil/) for this example. If you are using an existing EIP-7702 compatible network, you can skip this step. - -```bash -curl -L https://foundry.paradigm.xyz | bash -anvil --hardfork prague -``` - -### 1. Set up a Client - -We will need to set up a Client to sign EIP-7702 Authorizations. - -```ts twoslash -import { createWalletClient, http } from 'viem' -import { anvil } from 'viem/chains' - -const walletClient = createWalletClient({ - chain: anvil, - transport: http(), -}) -``` - -[See `createWalletClient` Docs](/docs/clients/wallet) - -### 2. Extend with EIP-7702 Actions - -Next, we will import the experimental EIP-7702 Actions and extend them on our Client. - -```ts twoslash -import { createWalletClient, http } from 'viem' -import { anvil } from 'viem/chains' -import { eip7702Actions } from 'viem/experimental' // [!code focus] - -const walletClient = createWalletClient({ - chain: anvil, - transport: http(), -}).extend(eip7702Actions()) // [!code focus] -``` - -### 3. Use EIP-7702 Actions - -Now we can use EIP-7702 Actions like [`signAuthorization`](/experimental/eip7702/signAuthorization). - -```ts twoslash -// @noErrors -import { createWalletClient, http } from 'viem' -import { anvil } from 'viem/chains' -import { eip7702Actions } from 'viem/experimental' - -const walletClient = createWalletClient({ - chain: anvil, - transport: http(), -}).extend(eip7702Actions()) - -const authorization = await walletClient.signAuthorization({/* ... */}) // [!code focus] -``` \ No newline at end of file diff --git a/site/pages/experimental/eip7702/contract-writes.md b/site/pages/experimental/eip7702/contract-writes.md deleted file mode 100644 index 8feefc18e2..0000000000 --- a/site/pages/experimental/eip7702/contract-writes.md +++ /dev/null @@ -1,420 +0,0 @@ -# Contract Writes with EIP-7702 - -The guide below demonstrates how to perform Contract Writes with EIP-7702 to invoke Contract functions on an Externally Owned Account. - -## Overview - -Here is an end-to-end overview of how to perform a Contract Write to send a batch of Calls. We will break it down into [Steps](#steps) below. - -:::code-group - -```ts twoslash [example.ts] -import { parseEther } from 'viem' -import { walletClient } from './config' -import { abi, contractAddress } from './contract' - -// 1. Authorize injection of the Contract's bytecode into our Account. -const authorization = await walletClient.signAuthorization({ - contractAddress, -}) - -// 2. Invoke the Contract's `execute` function to perform batch calls. -const hash = await walletClient.writeContract({ - abi, - address: walletClient.account.address, - functionName: 'execute', - args: [[ - { - data: '0x', - to: '0xcb98643b8786950F0461f3B0edf99D88F274574D', - value: parseEther('0.001'), - }, { - data: '0x', - to: '0xd2135CfB216b74109775236E36d4b433F1DF507B', - value: parseEther('0.002'), - } - ]], - authorizationList: [authorization], - // ↑ 3. Pass the Authorization as an option. -}) -``` - -```ts twoslash [contract.ts] filename="contract.ts" -export const abi = [ - { - "type": "function", - "name": "execute", - "inputs": [ - { - "name": "calls", - "type": "tuple[]", - "components": [ - { - "name": "data", - "type": "bytes", - }, - { - "name": "to", - "type": "address", - }, - { - "name": "value", - "type": "uint256", - } - ] - } - ], - "outputs": [], - "stateMutability": "payable" - }, -] as const - -export const contractAddress = '0x...' -``` - -```ts twoslash [config.ts] filename="config.ts" -import { createWalletClient, http } from 'viem' -import { anvil } from 'viem/chains' -import { privateKeyToAccount } from 'viem/accounts' -import { eip7702Actions } from 'viem/experimental' - -export const account = privateKeyToAccount('0x...') - -export const walletClient = createWalletClient({ - account, - chain: anvil, - transport: http(), -}).extend(eip7702Actions()) -``` - -```solidity [BatchCallDelegation.sol] -pragma solidity ^0.8.20; - -contract BatchCallDelegation { - struct Call { - bytes data; - address to; - uint256 value; - } - - function execute(Call[] calldata calls) external payable { - for (uint256 i = 0; i < calls.length; i++) { - Call memory call = calls[i]; - (bool success, ) = call.to.call{value: call.value}(call.data); - require(success, "call reverted"); - } - } -} -``` - -::: - -:::warning -EIP-7702 is currently not supported on Ethereum anvil or Testnets. For this example, we are using the `anvil` chain which interfaces with an [Anvil node](https://book.getfoundry.sh/anvil/) (a local Ethereum network). -::: - -## Steps - -### 0. Install & Run Anvil - -EIP-7702 is currently not supported on Ethereum Mainnet or Testnets, so let's set up an EIP-7702 compatible network. We will use an [Anvil node](https://book.getfoundry.sh/anvil/) for this example. If you are using an existing EIP-7702 compatible network, you can skip this step. - -```bash -curl -L https://foundry.paradigm.xyz | bash -anvil --hardfork prague -``` - -### 1. Set up Smart Contract - -We will need to set up a Smart Contract to interact with. For the purposes of this guide, we will [create](https://book.getfoundry.sh/reference/forge/forge-init) and [deploy](https://book.getfoundry.sh/forge/deploying) a `BatchCallDelegation.sol` contract, however, you can use any existing deployed contract. - -Firstly, [deploy a Contract](https://book.getfoundry.sh/forge/deploying) to the Network with the following source: - -```solidity [BatchCallDelegation.sol] -pragma solidity ^0.8.20; - -contract BatchCallDelegation { - struct Call { - bytes data; - address to; - uint256 value; - } - - function execute(Call[] calldata calls) external payable { - for (uint256 i = 0; i < calls.length; i++) { - Call memory call = calls[i]; - (bool success, ) = call.to.call{value: call.value}(call.data); - require(success, "call reverted"); - } - } -} -``` - -:::warning - -**DO NOT USE IN PRODUCTION** - -This contract is for demonstration purposes only to show how EIP-7702 works. If [someone else (Sponsor Account) is executing calls](#5-optional-use-a-sponsor) on behalf of the Account, it does not implement a nonce & signature verification mechanism to prevent replay attacks. - -::: - -### 2. Set up Client & Account - -Next, we will need to set up a Client and Externally Owned Account to sign EIP-7702 Authorizations. - -This code snippet uses the [Extending Client](/experimental/eip7702/client) guide. - -```ts twoslash [config.ts] -import { createWalletClient, http } from 'viem' -import { anvil } from 'viem/chains' -import { privateKeyToAccount } from 'viem/accounts' -import { eip7702Actions } from 'viem/experimental' - -export const account = privateKeyToAccount('0x...') - -export const walletClient = createWalletClient({ - account, - chain: anvil, - transport: http(), -}).extend(eip7702Actions()) -``` - -### 3. Authorize Contract Designation - -We will need to sign an Authorization to designate the Contract to the Account. - -In the example below, we are using the `account` attached to the `walletClient` to sign the Authorization – this will be the Account that the Contract's bytecode will be injected into. - -:::code-group - -```ts twoslash [example.ts] -import { walletClient } from './config' -import { contractAddress } from './contract' - -const authorization = await walletClient.signAuthorization({ // [!code focus] - contractAddress, // [!code focus] -}) // [!code focus] -``` - -```ts twoslash [contract.ts] filename="contract.ts" -export const abi = [ - { - "type": "function", - "name": "execute", - "inputs": [ - { - "name": "calls", - "type": "tuple[]", - "components": [ - { - "name": "data", - "type": "bytes", - }, - { - "name": "to", - "type": "address", - }, - { - "name": "value", - "type": "uint256", - } - ] - } - ], - "outputs": [], - "stateMutability": "payable" - }, -] as const - -export const contractAddress = '0x...' -``` - -```ts twoslash [config.ts] -import { createWalletClient, http } from 'viem' -import { anvil } from 'viem/chains' -import { privateKeyToAccount } from 'viem/accounts' -import { eip7702Actions } from 'viem/experimental' - -export const account = privateKeyToAccount('0x...') - -export const walletClient = createWalletClient({ - account, - chain: anvil, - transport: http(), -}).extend(eip7702Actions()) -``` - -::: - -### 4. Invoke Contract Function - -Using our [Contract Instance](/docs/contract/getContract), we can now call the `execute` function on it to perform batch calls. - -:::code-group - -```ts twoslash [example.ts] -import { parseEther } from 'viem' -import { walletClient } from './config' -import { abi, contractAddress } from './contract' - -const authorization = await walletClient.signAuthorization({ - contractAddress, -}) - -const hash = await walletClient.writeContract({ // [!code focus] - abi, // [!code focus] - address: walletClient.account.address, // [!code focus] - functionName: 'execute', // [!code focus] - args: [[ // [!code focus] - { // [!code focus] - data: '0x', // [!code focus] - to: '0xcb98643b8786950F0461f3B0edf99D88F274574D', // [!code focus] - value: parseEther('0.001'), // [!code focus] - }, { // [!code focus] - data: '0x', // [!code focus] - to: '0xd2135CfB216b74109775236E36d4b433F1DF507B', // [!code focus] - value: parseEther('0.002'), // [!code focus] - } // [!code focus] - ]], // [!code focus] - authorizationList: [authorization], // [!code focus] -}) // [!code focus] -``` - -```ts twoslash [contract.ts] filename="contract.ts" -export const abi = [ - { - "type": "function", - "name": "execute", - "inputs": [ - { - "name": "calls", - "type": "tuple[]", - "components": [ - { - "name": "data", - "type": "bytes", - }, - { - "name": "to", - "type": "address", - }, - { - "name": "value", - "type": "uint256", - } - ] - } - ], - "outputs": [], - "stateMutability": "payable" - }, -] as const - -export const contractAddress = '0x...' -``` - -```ts twoslash [config.ts] -import { createWalletClient, http } from 'viem' -import { anvil } from 'viem/chains' -import { privateKeyToAccount } from 'viem/accounts' -import { eip7702Actions } from 'viem/experimental' - -export const account = privateKeyToAccount('0x...') - -export const walletClient = createWalletClient({ - account, - chain: anvil, - transport: http(), -}).extend(eip7702Actions()) -``` - -::: - -### 5. Optional: Use a Sponsor - -We can also utilize an Sponsor Account to execute a call on behalf of the authorizing Account. This is useful for cases where we want to "sponsor" the Transaction for the user (i.e. pay for their gas fees). - -:::code-group - -```ts twoslash [example.ts] -import { parseEther } from 'viem' -import { walletClient } from './config' -import { abi, contractAddress } from './contract' - -const sponsor = privateKeyToAccount('0x...') // [!code ++] - -const authorization = await walletClient.signAuthorization({ - contractAddress, - sponsor, // [!code ++] -}) - -const hash = await walletClient.writeContract({ - account: sponsor, // [!code ++] - abi, - address: walletClient.account.address, - functionName: 'execute', - args: [[ - { - data: '0x', - to: '0xcb98643b8786950F0461f3B0edf99D88F274574D', - value: parseEther('0.001'), - }, { - data: '0x', - to: '0xd2135CfB216b74109775236E36d4b433F1DF507B', - value: parseEther('0.002'), - } - ]], - authorizationList: [authorization], -}) -``` - -```ts twoslash [config.ts] -// @noErrors -import { createWalletClient, http } from 'viem' -import { anvil } from 'viem/chains' -import { privateKeyToAccount } from 'viem/accounts' -import { eip7702Actions } from 'viem/experimental' - -export const account = privateKeyToAccount('0x...') - -export const walletClient = createWalletClient({ - account, - chain: anvil, - transport: http(), -}).extend(eip7702Actions()) -``` - -```ts twoslash [contract.ts] filename="contract.ts" -export const abi = [ - { - "type": "function", - "name": "execute", - "inputs": [ - { - "name": "calls", - "type": "tuple[]", - "components": [ - { - "name": "data", - "type": "bytes", - }, - { - "name": "to", - "type": "address", - }, - { - "name": "value", - "type": "uint256", - } - ] - } - ], - "outputs": [], - "stateMutability": "payable" - }, -] as const - -export const contractAddress = '0x...' -``` - -::: diff --git a/site/pages/experimental/eip7702/sending-transactions.md b/site/pages/experimental/eip7702/sending-transactions.md deleted file mode 100644 index 3a31735467..0000000000 --- a/site/pages/experimental/eip7702/sending-transactions.md +++ /dev/null @@ -1,434 +0,0 @@ -# Sending Transactions with EIP-7702 - -The guide below demonstrates how to send EIP-7702 Transactions to invoke Contract functions on an Externally Owned Account. - -## Overview - -Here is an end-to-end overview of how to broadcast an EIP-7702 Transaction to emit a simple event on the EOA's designated contract. We will break it down into [Steps](#steps) below. - -:::code-group - -```ts twoslash [example.ts] -import { parseEther } from 'viem' -import { walletClient } from './config' -import { abi, contractAddress } from './contract' - -// 1. Authorize injection of the Contract's bytecode into our Account. -const authorization = await walletClient.signAuthorization({ - contractAddress, -}) - -// 2. Invoke the Contract's `execute` function to perform batch calls. -const hash = await walletClient.sendTransaction({ - authorizationList: [authorization], - data: encodeFunctionData({ - abi, - functionName: 'execute', - args: [ - [ - { - data: '0x', - to: '0xcb98643b8786950F0461f3B0edf99D88F274574D', - value: parseEther('0.001'), - }, - { - data: '0x', - to: '0xd2135CfB216b74109775236E36d4b433F1DF507B', - value: parseEther('0.002'), - }, - ], - ] - }), - to: walletClient.account.address, -}) -``` - -```ts twoslash [contract.ts] filename="contract.ts" -export const abi = [ - { - "type": "function", - "name": "execute", - "inputs": [ - { - "name": "calls", - "type": "tuple[]", - "components": [ - { - "name": "data", - "type": "bytes", - }, - { - "name": "to", - "type": "address", - }, - { - "name": "value", - "type": "uint256", - } - ] - } - ], - "outputs": [], - "stateMutability": "payable" - }, -] as const - -export const contractAddress = '0x...' -``` - -```ts twoslash [config.ts] filename="config.ts" -import { createWalletClient, http } from 'viem' -import { anvil } from 'viem/chains' -import { privateKeyToAccount } from 'viem/accounts' -import { eip7702Actions } from 'viem/experimental' - -export const account = privateKeyToAccount('0x...') - -export const walletClient = createWalletClient({ - account, - chain: anvil, - transport: http(), -}).extend(eip7702Actions()) -``` - -```solidity [BatchCallDelegation.sol] -pragma solidity ^0.8.20; - -contract BatchCallDelegation { - struct Call { - bytes data; - address to; - uint256 value; - } - - function execute(Call[] calldata calls) external payable { - for (uint256 i = 0; i < calls.length; i++) { - Call memory call = calls[i]; - (bool success, ) = call.to.call{value: call.value}(call.data); - require(success, "call reverted"); - } - } -} -``` - -::: - -:::warning -EIP-7702 is currently not supported on Ethereum anvil or Testnets. For this example, we are using the `anvil` chain which interfaces with an [Anvil node](https://book.getfoundry.sh/anvil/) (a local Ethereum network). -::: - -## Steps - -### 0. Install & Run Anvil - -EIP-7702 is currently not supported on Ethereum Mainnet or Testnets, so let's set up an EIP-7702 compatible network. We will use an [Anvil node](https://book.getfoundry.sh/anvil/) for this example. If you are using an existing EIP-7702 compatible network, you can skip this step. - -```bash -curl -L https://foundry.paradigm.xyz | bash -anvil --hardfork prague -``` - -### 1. Set up Smart Contract - -We will need to set up a Smart Contract to interact with. For the purposes of this guide, we will [create](https://book.getfoundry.sh/reference/forge/forge-init) and [deploy](https://book.getfoundry.sh/forge/deploying) a `BatchCallDelegation.sol` contract, however, you can use any existing deployed contract. - -Firstly, [deploy a Contract](https://book.getfoundry.sh/forge/deploying) to the Network with the following source: - -```solidity [BatchCallDelegation.sol] -pragma solidity ^0.8.20; - -contract BatchCallDelegation { - struct Call { - bytes data; - address to; - uint256 value; - } - - function execute(Call[] calldata calls) external payable { - for (uint256 i = 0; i < calls.length; i++) { - Call memory call = calls[i]; - (bool success, ) = call.to.call{value: call.value}(call.data); - require(success, "call reverted"); - } - } -} -``` - -:::warning - -**DO NOT USE IN PRODUCTION** - -This contract is for demonstration purposes only to show how EIP-7702 works. If [someone else (Sponsor Account) is executing calls](#5-optional-use-a-sponsor) on behalf of the Account, it does not implement a nonce & signature verification mechanism to prevent replay attacks. - -::: - -### 2. Set up Client & Account - -Next, we will need to set up a Client and Externally Owned Account to sign EIP-7702 Authorizations. - -This code snippet uses the [Extending Client](/experimental/eip7702/client) guide. - -```ts twoslash [config.ts] -import { createWalletClient, http } from 'viem' -import { anvil } from 'viem/chains' -import { privateKeyToAccount } from 'viem/accounts' -import { eip7702Actions } from 'viem/experimental' - -export const account = privateKeyToAccount('0x...') - -export const walletClient = createWalletClient({ - account, - chain: anvil, - transport: http(), -}).extend(eip7702Actions()) -``` - -### 3. Authorize Contract Designation - -We will need to sign an Authorization to designate the Contract to the Account. - -In the example below, we are using the `account` attached to the `walletClient` to sign the Authorization – this will be the Account that the Contract's bytecode will be injected into. - -:::code-group - -```ts twoslash [example.ts] -import { walletClient } from './config' -import { contractAddress } from './contract' - -const authorization = await walletClient.signAuthorization({ // [!code focus] - contractAddress, // [!code focus] -}) // [!code focus] -``` - -```ts twoslash [contract.ts] filename="contract.ts" -export const abi = [ - { - "type": "function", - "name": "execute", - "inputs": [ - { - "name": "calls", - "type": "tuple[]", - "components": [ - { - "name": "data", - "type": "bytes", - }, - { - "name": "to", - "type": "address", - }, - { - "name": "value", - "type": "uint256", - } - ] - } - ], - "outputs": [], - "stateMutability": "payable" - }, -] as const - -export const contractAddress = '0x...' -``` - -```ts twoslash [config.ts] -import { createWalletClient, http } from 'viem' -import { anvil } from 'viem/chains' -import { privateKeyToAccount } from 'viem/accounts' -import { eip7702Actions } from 'viem/experimental' - -export const account = privateKeyToAccount('0x...') - -export const walletClient = createWalletClient({ - account, - chain: anvil, - transport: http(), -}).extend(eip7702Actions()) -``` - -::: - -### 4. Invoke Contract Function - -We can now perform batch calls by sending a Transaction to the Account (`account`) with the Authorization (`authorizationList`). - -:::code-group - -```ts twoslash [example.ts] -import { encodeFunctionData, parseEther } from 'viem' -import { walletClient } from './config' -import { contractAddress } from './contract' - -const authorization = await walletClient.signAuthorization({ - contractAddress, -}) - -const hash = await walletClient.sendTransaction({ // [!code focus] - authorizationList: [authorization], // [!code focus] - data: encodeFunctionData({ // [!code focus] - abi, // [!code focus] - functionName: 'execute', // [!code focus] - args: [ // [!code focus] - [ // [!code focus] - { // [!code focus] - data: '0x', // [!code focus] - to: '0xcb98643b8786950F0461f3B0edf99D88F274574D', // [!code focus] - value: parseEther('0.001'), // [!code focus] - }, // [!code focus] - { // [!code focus] - data: '0x', // [!code focus] - to: '0xd2135CfB216b74109775236E36d4b433F1DF507B', // [!code focus] - value: parseEther('0.002'), // [!code focus] - }, // [!code focus] - ], // [!code focus] - ] // [!code focus] - }), // [!code focus] - to: walletClient.account.address, // [!code focus] -}) // [!code focus] -``` - -```ts twoslash [contract.ts] filename="contract.ts" -export const abi = [ - { - "type": "function", - "name": "execute", - "inputs": [ - { - "name": "calls", - "type": "tuple[]", - "components": [ - { - "name": "data", - "type": "bytes", - }, - { - "name": "to", - "type": "address", - }, - { - "name": "value", - "type": "uint256", - } - ] - } - ], - "outputs": [], - "stateMutability": "payable" - }, -] as const - -export const contractAddress = '0x...' -``` - -```ts twoslash [config.ts] -import { createWalletClient, http } from 'viem' -import { anvil } from 'viem/chains' -import { privateKeyToAccount } from 'viem/accounts' -import { eip7702Actions } from 'viem/experimental' - -export const account = privateKeyToAccount('0x...') - -export const walletClient = createWalletClient({ - account, - chain: anvil, - transport: http(), -}).extend(eip7702Actions()) -``` - -::: - -### 5. Optional: Use a Sponsor - -We can also utilize an Sponsor Account to execute a call on behalf of the authorizing Account. This is useful for cases where we want to "sponsor" the Transaction for the user (i.e. pay for their gas fees). - -:::code-group - -```ts twoslash [example.ts] -import { encodeFunctionData, parseEther } from 'viem' -import { walletClient } from './config' -import { contractAddress } from './contract' - -const sponsor = privateKeyToAccount('0x...') // [!code ++] - -const authorization = await walletClient.signAuthorization({ - contractAddress, - sponsor, // [!code ++] -}) - -const hash = await walletClient.sendTransaction({ - account: sponsor, // [!code ++] - authorizationList: [authorization], - data: encodeFunctionData({ - abi, - functionName: 'execute', - args: [ - [ - { - data: '0x', - to: '0xcb98643b8786950F0461f3B0edf99D88F274574D', - value: parseEther('0.001'), - }, - { - data: '0x', - to: '0xd2135CfB216b74109775236E36d4b433F1DF507B', - value: parseEther('0.002'), - }, - ], - ] - }), - to: walletClient.account.address, -}) -``` - -```ts twoslash [config.ts] -// @noErrors -import { createWalletClient, http } from 'viem' -import { anvil } from 'viem/chains' -import { privateKeyToAccount } from 'viem/accounts' -import { eip7702Actions } from 'viem/experimental' - -export const account = privateKeyToAccount('0x...') - -export const walletClient = createWalletClient({ - account, - chain: anvil, - transport: http(), -}).extend(eip7702Actions()) -``` - -```ts twoslash [contract.ts] filename="contract.ts" -export const abi = [ - { - "type": "function", - "name": "execute", - "inputs": [ - { - "name": "calls", - "type": "tuple[]", - "components": [ - { - "name": "data", - "type": "bytes", - }, - { - "name": "to", - "type": "address", - }, - { - "name": "value", - "type": "uint256", - } - ] - } - ], - "outputs": [], - "stateMutability": "payable" - }, -] as const - -export const contractAddress = '0x...' -``` - -::: \ No newline at end of file diff --git a/site/pages/experimental/erc7821/execute.md b/site/pages/experimental/erc7821/execute.md index 03219562b7..4f48d67ffe 100644 --- a/site/pages/experimental/erc7821/execute.md +++ b/site/pages/experimental/erc7821/execute.md @@ -353,8 +353,8 @@ const hash = await client.execute({ :::note **References** -- [EIP-7702 Overview](/experimental/eip7702) -- [`signAuthorization` Docs](/experimental/eip7702/signAuthorization) +- [EIP-7702 Overview](/docs/eip7702) +- [`signAuthorization` Docs](/docs/eip7702/signAuthorization) ::: ### chain (optional) diff --git a/site/pages/experimental/erc7821/executeBatches.md b/site/pages/experimental/erc7821/executeBatches.md index fde81e160b..379dc4c983 100644 --- a/site/pages/experimental/erc7821/executeBatches.md +++ b/site/pages/experimental/erc7821/executeBatches.md @@ -410,8 +410,8 @@ const hash = await client.execute({ :::note **References** -- [EIP-7702 Overview](/experimental/eip7702) -- [`signAuthorization` Docs](/experimental/eip7702/signAuthorization) +- [EIP-7702 Overview](/docs/eip7702) +- [`signAuthorization` Docs](/docs/eip7702/signAuthorization) ::: ### chain (optional) diff --git a/site/sidebar.ts b/site/sidebar.ts index 1cfeea5653..8e39d92a21 100644 --- a/site/sidebar.ts +++ b/site/sidebar.ts @@ -772,6 +772,59 @@ export const sidebar = { }, ], }, + { + text: 'EIP-7702', + collapsed: true, + items: [ + { + text: 'Overview', + link: '/docs/eip7702', + }, + { + text: 'Guides', + items: [ + { + text: 'Contract Writes', + link: '/docs/eip7702/contract-writes', + }, + { + text: 'Sending Transactions', + link: '/docs/eip7702/sending-transactions', + }, + ], + }, + { + text: 'Actions', + items: [ + { + text: 'prepareAuthorization', + link: '/docs/eip7702/prepareAuthorization', + }, + { + text: 'signAuthorization', + link: '/docs/eip7702/signAuthorization', + }, + ], + }, + { + text: 'Utilities', + items: [ + { + text: 'hashAuthorization', + link: '/docs/eip7702/hashAuthorization', + }, + { + text: 'recoverAuthorizationAddress', + link: '/docs/eip7702/recoverAuthorizationAddress', + }, + { + text: 'verifyAuthorization', + link: '/docs/eip7702/verifyAuthorization', + }, + ], + }, + ], + }, { text: 'Utilities', collapsed: true, @@ -1297,62 +1350,6 @@ export const sidebar = { }, ], }, - { - text: 'EIP-7702', - items: [ - { - text: 'Overview', - link: '/experimental/eip7702', - }, - { - text: 'Guides', - items: [ - { - text: 'Extending Client', - link: '/experimental/eip7702/client', - }, - { - text: 'Contract Writes', - link: '/experimental/eip7702/contract-writes', - }, - { - text: 'Sending Transactions', - link: '/experimental/eip7702/sending-transactions', - }, - ], - }, - { - text: 'Actions', - items: [ - { - text: 'prepareAuthorization', - link: '/experimental/eip7702/prepareAuthorization', - }, - { - text: 'signAuthorization', - link: '/experimental/eip7702/signAuthorization', - }, - ], - }, - { - text: 'Utilities', - items: [ - { - text: 'hashAuthorization', - link: '/experimental/eip7702/hashAuthorization', - }, - { - text: 'recoverAuthorizationAddress', - link: '/experimental/eip7702/recoverAuthorizationAddress', - }, - { - text: 'verifyAuthorization', - link: '/experimental/eip7702/verifyAuthorization', - }, - ], - }, - ], - }, { text: 'ERC-7715', items: [ diff --git a/site/vercel.json b/site/vercel.json index 666e4c39ed..3757902d50 100644 --- a/site/vercel.json +++ b/site/vercel.json @@ -63,6 +63,10 @@ { "source": "/:match/simulate", "destination": "/:match/simulateBlocks" + }, + { + "source": "/docs/eip7702/:path*", + "destination": "/docs/eip7702/:path*" } ] } diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md index 6e4fd43880..14432e836f 100644 --- a/src/CHANGELOG.md +++ b/src/CHANGELOG.md @@ -1342,7 +1342,7 @@ ### Minor Changes -- [#2570](https://github.com/wevm/viem/pull/2570) [`fee80a9a`](https://github.com/wevm/viem/commit/fee80a9ae3e425354f21a6de5fa397244577eb28) Thanks [@jxom](https://github.com/jxom)! - **Experimental:** Added EIP-7702 Extension. [See Docs](https://viem.sh/experimental/eip7702) +- [#2570](https://github.com/wevm/viem/pull/2570) [`fee80a9a`](https://github.com/wevm/viem/commit/fee80a9ae3e425354f21a6de5fa397244577eb28) Thanks [@jxom](https://github.com/jxom)! - **Experimental:** Added EIP-7702 Extension. [See Docs](https://viem.sh/docs/eip7702) - [#2586](https://github.com/wevm/viem/pull/2586) [`0b1693aa`](https://github.com/wevm/viem/commit/0b1693aa51468cfe77dae74ad44bd89dfd21fd0e) Thanks [@tmm](https://github.com/tmm)! - Renamed "zkSync" to "ZKsync": diff --git a/src/accounts/hdKeyToAccount.test.ts b/src/accounts/hdKeyToAccount.test.ts index 816e57e7df..0818fc0778 100644 --- a/src/accounts/hdKeyToAccount.test.ts +++ b/src/accounts/hdKeyToAccount.test.ts @@ -20,11 +20,11 @@ test('default', () => { expect(hdKeyToAccount(hdKey)).toMatchInlineSnapshot(` { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "getHdKey": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], diff --git a/src/accounts/index.test.ts b/src/accounts/index.test.ts index ae4076eb7d..a56e816570 100644 --- a/src/accounts/index.test.ts +++ b/src/accounts/index.test.ts @@ -26,7 +26,7 @@ test('exports utils', () => { "sign", "signatureToHex", "serializeSignature", - "experimental_signAuthorization", + "signAuthorization", "signMessage", "signTransaction", "signTypedData", diff --git a/src/accounts/index.ts b/src/accounts/index.ts index 8569fc061e..a2ecaf7e2a 100644 --- a/src/accounts/index.ts +++ b/src/accounts/index.ts @@ -70,7 +70,7 @@ export { type SignAuthorizationErrorType, type SignAuthorizationParameters, type SignAuthorizationReturnType, - experimental_signAuthorization, + signAuthorization, } from './utils/signAuthorization.js' export { type SignMessageErrorType, diff --git a/src/accounts/mnemonicToAccount.test.ts b/src/accounts/mnemonicToAccount.test.ts index 0085e2ad3a..a11dbdb247 100644 --- a/src/accounts/mnemonicToAccount.test.ts +++ b/src/accounts/mnemonicToAccount.test.ts @@ -13,11 +13,11 @@ test('default', () => { expect(mnemonicToAccount(mnemonic)).toMatchInlineSnapshot(` { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "getHdKey": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], diff --git a/src/accounts/privateKeyToAccount.test.ts b/src/accounts/privateKeyToAccount.test.ts index 479698010d..08f44af4f9 100644 --- a/src/accounts/privateKeyToAccount.test.ts +++ b/src/accounts/privateKeyToAccount.test.ts @@ -11,10 +11,10 @@ test('default', () => { expect(privateKeyToAccount(accounts[0].privateKey)).toMatchInlineSnapshot(` { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -37,7 +37,7 @@ test('sign', async () => { test('sign authorization', async () => { const account = privateKeyToAccount(accounts[0].privateKey) - const signedAuthorization = await account.experimental_signAuthorization({ + const signedAuthorization = await account.signAuthorization({ contractAddress: wagmiContractConfig.address, chainId: 1, nonce: 0, diff --git a/src/accounts/privateKeyToAccount.ts b/src/accounts/privateKeyToAccount.ts index 77182df937..ee0cc88ebc 100644 --- a/src/accounts/privateKeyToAccount.ts +++ b/src/accounts/privateKeyToAccount.ts @@ -12,7 +12,7 @@ import { publicKeyToAddress, } from './utils/publicKeyToAddress.js' import { type SignErrorType, sign } from './utils/sign.js' -import { experimental_signAuthorization } from './utils/signAuthorization.js' +import { signAuthorization } from './utils/signAuthorization.js' import { type SignMessageErrorType, signMessage } from './utils/signMessage.js' import { type SignTransactionErrorType, @@ -56,8 +56,8 @@ export function privateKeyToAccount( async sign({ hash }) { return sign({ hash, privateKey, to: 'hex' }) }, - async experimental_signAuthorization(authorization) { - return experimental_signAuthorization({ ...authorization, privateKey }) + async signAuthorization(authorization) { + return signAuthorization({ ...authorization, privateKey }) }, async signMessage({ message }) { return signMessage({ message, privateKey }) diff --git a/src/accounts/toAccount.test.ts b/src/accounts/toAccount.test.ts index 81a4fefef9..e2e4bce38e 100644 --- a/src/accounts/toAccount.test.ts +++ b/src/accounts/toAccount.test.ts @@ -42,9 +42,9 @@ describe('toAccount', () => { ).toMatchInlineSnapshot(` { "address": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", - "experimental_signAuthorization": undefined, "nonceManager": undefined, "sign": undefined, + "signAuthorization": undefined, "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], diff --git a/src/accounts/toAccount.ts b/src/accounts/toAccount.ts index e37031b154..743af63db6 100644 --- a/src/accounts/toAccount.ts +++ b/src/accounts/toAccount.ts @@ -51,7 +51,7 @@ export function toAccount( address: source.address, nonceManager: source.nonceManager, sign: source.sign, - experimental_signAuthorization: source.experimental_signAuthorization, + signAuthorization: source.signAuthorization, signMessage: source.signMessage, signTransaction: source.signTransaction, signTypedData: source.signTypedData, diff --git a/src/accounts/types.ts b/src/accounts/types.ts index c59b44cfc6..9349db52c6 100644 --- a/src/accounts/types.ts +++ b/src/accounts/types.ts @@ -1,8 +1,8 @@ import type { Address, TypedData } from 'abitype' import type { SmartAccount } from '../account-abstraction/accounts/types.js' -import type { Authorization } from '../experimental/eip7702/types/authorization.js' import type { HDKey } from '../types/account.js' +import type { Authorization } from '../types/authorization.js' import type { Hash, Hex, SignableMessage } from '../types/misc.js' import type { TransactionSerializable, @@ -29,7 +29,7 @@ export type CustomSource = { nonceManager?: NonceManager | undefined // TODO(v3): Make `sign` required. sign?: ((parameters: { hash: Hash }) => Promise) | undefined - experimental_signAuthorization?: + signAuthorization?: | ((parameters: Authorization) => Promise) | undefined signMessage: ({ message }: { message: SignableMessage }) => Promise @@ -111,8 +111,6 @@ export type PrivateKeyAccount = Prettify< LocalAccount<'privateKey'> & { // TODO(v3): This will be redundant. sign: NonNullable - experimental_signAuthorization: NonNullable< - CustomSource['experimental_signAuthorization'] - > + signAuthorization: NonNullable } > diff --git a/src/accounts/utils/parseAccount.test.ts b/src/accounts/utils/parseAccount.test.ts index 16450c080b..dfe81e0eac 100644 --- a/src/accounts/utils/parseAccount.test.ts +++ b/src/accounts/utils/parseAccount.test.ts @@ -22,10 +22,10 @@ test('account', () => { ).toMatchInlineSnapshot(` { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], diff --git a/src/accounts/utils/signAuthorization.test.ts b/src/accounts/utils/signAuthorization.test.ts index eacc0c240d..45a91a5084 100644 --- a/src/accounts/utils/signAuthorization.test.ts +++ b/src/accounts/utils/signAuthorization.test.ts @@ -3,11 +3,11 @@ import { expect, test } from 'vitest' import { accounts } from '~test/src/constants.js' import { wagmiContractConfig } from '../../../test/src/abis.js' -import { verifyAuthorization } from '../../experimental/eip7702/utils/verifyAuthorization.js' -import { experimental_signAuthorization } from './signAuthorization.js' +import { verifyAuthorization } from '../../utils/authorization/verifyAuthorization.js' +import { signAuthorization } from './signAuthorization.js' test('default', async () => { - const signedAuthorization = await experimental_signAuthorization({ + const signedAuthorization = await signAuthorization({ contractAddress: wagmiContractConfig.address, chainId: 1, nonce: 0, @@ -45,13 +45,48 @@ test('default', async () => { ).toBe(true) }) +test('args: address (alias)', async () => { + const signedAuthorization = await signAuthorization({ + address: wagmiContractConfig.address, + chainId: 1, + nonce: 0, + privateKey: accounts[0].privateKey, + }) + + expect({ + ...signedAuthorization, + r: null, + s: null, + v: null, + yParity: null, + }).toMatchInlineSnapshot( + ` + { + "chainId": 1, + "contractAddress": "0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2", + "nonce": 0, + "r": null, + "s": null, + "v": null, + "yParity": null, + } + `, + ) + expect( + await verifyAuthorization({ + address: accounts[0].address, + authorization: signedAuthorization, + }), + ).toBe(true) +}) + test('args: to (hex)', async () => { const authorization = { contractAddress: wagmiContractConfig.address, chainId: 1, nonce: 0, } - const signature = await experimental_signAuthorization({ + const signature = await signAuthorization({ ...authorization, privateKey: accounts[0].privateKey, to: 'hex', diff --git a/src/accounts/utils/signAuthorization.ts b/src/accounts/utils/signAuthorization.ts index 599c33568b..4558746982 100644 --- a/src/accounts/utils/signAuthorization.ts +++ b/src/accounts/utils/signAuthorization.ts @@ -2,13 +2,13 @@ import type { ErrorType } from '../../errors/utils.js' import type { Authorization, SignedAuthorization, -} from '../../experimental/eip7702/types/authorization.js' +} from '../../types/authorization.js' +import type { Hex, Signature } from '../../types/misc.js' +import type { Prettify } from '../../types/utils.js' import { type HashAuthorizationErrorType, hashAuthorization, -} from '../../experimental/eip7702/utils/hashAuthorization.js' -import type { Hex, Signature } from '../../types/misc.js' -import type { Prettify } from '../../types/utils.js' +} from '../../utils/authorization/hashAuthorization.js' import { type SignErrorType, type SignParameters, @@ -37,16 +37,11 @@ export type SignAuthorizationErrorType = /** * Signs an Authorization hash in [EIP-7702 format](https://eips.ethereum.org/EIPS/eip-7702): `keccak256('0x05' || rlp([chain_id, address, nonce]))`. */ -export async function experimental_signAuthorization( +export async function signAuthorization( parameters: SignAuthorizationParameters, ): Promise> { - const { - contractAddress, - chainId, - nonce, - privateKey, - to = 'object', - } = parameters + const { chainId, nonce, privateKey, to = 'object' } = parameters + const contractAddress = parameters.contractAddress ?? parameters.address const signature = await sign({ hash: hashAuthorization({ contractAddress, chainId, nonce }), privateKey, diff --git a/src/accounts/utils/signTransaction.test.ts b/src/accounts/utils/signTransaction.test.ts index ae1586751f..9ce0447c86 100644 --- a/src/accounts/utils/signTransaction.test.ts +++ b/src/accounts/utils/signTransaction.test.ts @@ -32,12 +32,12 @@ const base = { describe('eip7702', async () => { const account = privateKeyToAccount(accounts[0].privateKey) - const signedAuthorization_1 = await account.experimental_signAuthorization({ + const signedAuthorization_1 = await account.signAuthorization({ contractAddress: wagmiContractConfig.address, chainId: 1, nonce: 420, }) - const signedAuthorization_2 = await account.experimental_signAuthorization({ + const signedAuthorization_2 = await account.signAuthorization({ contractAddress: wagmiContractConfig.address, chainId: 10, nonce: 69, diff --git a/src/actions/index.test.ts b/src/actions/index.test.ts index 979fe62d15..82751cca46 100644 --- a/src/actions/index.test.ts +++ b/src/actions/index.test.ts @@ -64,6 +64,7 @@ test('exports actions', () => { "loadState": [Function], "mine": [Function], "multicall": [Function], + "prepareAuthorization": [Function], "prepareTransactionRequest": [Function], "readContract": [Function], "removeBlockTimestampInterval": [Function], @@ -88,6 +89,7 @@ test('exports actions', () => { "setNonce": [Function], "setRpcUrl": [Function], "setStorageAt": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], diff --git a/src/actions/index.ts b/src/actions/index.ts index 09a5a031c6..95b68eff49 100644 --- a/src/actions/index.ts +++ b/src/actions/index.ts @@ -379,6 +379,12 @@ export { type RevertParameters, revert, } from './test/revert.js' +export { + type PrepareAuthorizationErrorType, + type PrepareAuthorizationParameters, + type PrepareAuthorizationReturnType, + prepareAuthorization, +} from './wallet/prepareAuthorization.js' export { type PrepareTransactionRequestErrorType, type PrepareTransactionRequestParameters, @@ -392,6 +398,12 @@ export { type SendTransactionReturnType, sendTransaction, } from './wallet/sendTransaction.js' +export { + type SignAuthorizationErrorType, + type SignAuthorizationParameters, + type SignAuthorizationReturnType, + signAuthorization, +} from './wallet/signAuthorization.js' export { type SignTransactionErrorType, type SignTransactionParameters, diff --git a/src/actions/public/estimateGas.test.ts b/src/actions/public/estimateGas.test.ts index 96b2117e0e..562db77009 100644 --- a/src/actions/public/estimateGas.test.ts +++ b/src/actions/public/estimateGas.test.ts @@ -8,13 +8,13 @@ import { maxUint256 } from '../../constants/number.js' import { BatchCallDelegation } from '../../../contracts/generated.js' import { deploy } from '../../../test/src/utils.js' -import { signAuthorization } from '../../experimental/index.js' import { toBlobs } from '../../utils/blob/toBlobs.js' import { toHex } from '../../utils/encoding/toHex.js' import { encodeFunctionData } from '../../utils/index.js' import { parseEther } from '../../utils/unit/parseEther.js' import { parseGwei } from '../../utils/unit/parseGwei.js' import { reset } from '../test/reset.js' +import { signAuthorization } from '../wallet/signAuthorization.js' import { estimateGas } from './estimateGas.js' import * as getBlock from './getBlock.js' @@ -52,7 +52,7 @@ test('args: account', async () => { }) test('args: authorizationList', async () => { - const authority = privateKeyToAccount(accounts[1].privateKey) + const eoa = privateKeyToAccount(accounts[1].privateKey) const { contractAddress } = await deploy(client, { abi: BatchCallDelegation.abi, @@ -60,7 +60,7 @@ test('args: authorizationList', async () => { }) const authorization = await signAuthorization(client, { - account: authority, + account: eoa, contractAddress: contractAddress!, }) diff --git a/src/actions/public/estimateGas.ts b/src/actions/public/estimateGas.ts index c441eee821..2ea374d3e5 100644 --- a/src/actions/public/estimateGas.ts +++ b/src/actions/public/estimateGas.ts @@ -7,15 +7,15 @@ import { import type { Client } from '../../clients/createClient.js' import type { Transport } from '../../clients/transports/createTransport.js' import { BaseError } from '../../errors/base.js' -import { - type RecoverAuthorizationAddressErrorType, - recoverAuthorizationAddress, -} from '../../experimental/eip7702/utils/recoverAuthorizationAddress.js' import type { BlockTag } from '../../types/block.js' import type { Chain } from '../../types/chain.js' import type { StateOverride } from '../../types/stateOverride.js' import type { TransactionRequest } from '../../types/transaction.js' import type { UnionOmit } from '../../types/utils.js' +import { + type RecoverAuthorizationAddressErrorType, + recoverAuthorizationAddress, +} from '../../utils/authorization/recoverAuthorizationAddress.js' import type { RequestErrorType } from '../../utils/buildRequest.js' import { type NumberToHexErrorType, diff --git a/src/actions/public/getTransaction.test.ts b/src/actions/public/getTransaction.test.ts index e5b99d4137..31f18e75e0 100644 --- a/src/actions/public/getTransaction.test.ts +++ b/src/actions/public/getTransaction.test.ts @@ -8,7 +8,6 @@ import { privateKeyToAccount } from '../../accounts/privateKeyToAccount.js' import { celo, holesky } from '../../chains/index.js' import { createPublicClient } from '../../clients/createPublicClient.js' import { http } from '../../clients/transports/http.js' -import { signAuthorization } from '../../experimental/index.js' import { createClient, encodeFunctionData } from '../../index.js' import type { Transaction } from '../../types/transaction.js' import { parseEther } from '../../utils/unit/parseEther.js' @@ -16,6 +15,7 @@ import { wait } from '../../utils/wait.js' import { mine } from '../test/mine.js' import { setBalance } from '../test/setBalance.js' import { sendTransaction } from '../wallet/sendTransaction.js' +import { signAuthorization } from '../wallet/signAuthorization.js' import { getBlock } from './getBlock.js' import { getTransaction } from './getTransaction.js' @@ -179,7 +179,7 @@ test('gets transaction (eip4844)', async () => { }) test('gets transaction (eip7702)', async () => { - const authority = privateKeyToAccount(accounts[1].privateKey) + const eoa = privateKeyToAccount(accounts[1].privateKey) const { contractAddress } = await deploy(client, { abi: BatchCallDelegation.abi, @@ -187,12 +187,12 @@ test('gets transaction (eip7702)', async () => { }) const authorization = await signAuthorization(client, { - account: authority, + account: eoa, contractAddress: contractAddress!, }) const hash = await sendTransaction(client, { - account: authority, + account: eoa, authorizationList: [authorization], data: encodeFunctionData({ abi: BatchCallDelegation.abi, diff --git a/src/actions/public/verifyHash.test.ts b/src/actions/public/verifyHash.test.ts index 801aedaf3e..6ab29f9969 100644 --- a/src/actions/public/verifyHash.test.ts +++ b/src/actions/public/verifyHash.test.ts @@ -23,12 +23,12 @@ import { zksync } from '../../chains/index.js' import { createClient } from '../../clients/createClient.js' import { http } from '../../clients/transports/http.js' import { signMessage as signMessageErc1271 } from '../../experimental/erc7739/actions/signMessage.js' -import { serializeErc6492Signature } from '../../experimental/index.js' import type { Hex } from '../../types/misc.js' import { encodeFunctionData, hashMessage, pad, + serializeErc6492Signature, toBytes, } from '../../utils/index.js' import { parseSignature } from '../../utils/signature/parseSignature.js' diff --git a/src/actions/wallet/deployContract.test.ts b/src/actions/wallet/deployContract.test.ts index 2d56562133..f8150efb10 100644 --- a/src/actions/wallet/deployContract.test.ts +++ b/src/actions/wallet/deployContract.test.ts @@ -9,9 +9,9 @@ import { setBalance } from '../test/setBalance.js' import { anvilMainnet } from '../../../test/src/anvil.js' import { privateKeyToAccount } from '../../accounts/privateKeyToAccount.js' -import { signAuthorization } from '../../experimental/eip7702/actions/signAuthorization.js' import { getTransactionReceipt } from '../public/getTransactionReceipt.js' import { deployContract } from './deployContract.js' +import { signAuthorization } from './signAuthorization.js' const client = anvilMainnet.getClient() const clientWithAccount = anvilMainnet.getClient({ diff --git a/src/experimental/eip7702/actions/prepareAuthorization.test.ts b/src/actions/wallet/prepareAuthorization.test.ts similarity index 78% rename from src/experimental/eip7702/actions/prepareAuthorization.test.ts rename to src/actions/wallet/prepareAuthorization.test.ts index a5967d8690..1cfcf25223 100644 --- a/src/experimental/eip7702/actions/prepareAuthorization.test.ts +++ b/src/actions/wallet/prepareAuthorization.test.ts @@ -1,9 +1,9 @@ import { beforeAll, expect, test } from 'vitest' -import { wagmiContractConfig } from '../../../../test/src/abis.js' -import { anvilMainnet } from '../../../../test/src/anvil.js' -import { accounts } from '../../../../test/src/constants.js' -import { privateKeyToAccount } from '../../../accounts/privateKeyToAccount.js' -import { reset } from '../../../actions/index.js' +import { wagmiContractConfig } from '../../../test/src/abis.js' +import { anvilMainnet } from '../../../test/src/anvil.js' +import { accounts } from '../../../test/src/constants.js' +import { privateKeyToAccount } from '../../accounts/privateKeyToAccount.js' +import { reset } from '../index.js' import { prepareAuthorization } from './prepareAuthorization.js' const account = privateKeyToAccount(accounts[0].privateKey) @@ -35,6 +35,25 @@ test('default', async () => { ) }) +test('args: address (alias)', async () => { + const authorization = await prepareAuthorization(client, { + account, + address: wagmiContractConfig.address, + chainId: 1, + nonce: 0, + }) + + expect(authorization).toMatchInlineSnapshot( + ` + { + "chainId": 1, + "contractAddress": "0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2", + "nonce": 0, + } + `, + ) +}) + test('behavior: partial authorization: no chainId + nonce', async () => { const authorization = await prepareAuthorization(client, { account, @@ -46,7 +65,7 @@ test('behavior: partial authorization: no chainId + nonce', async () => { { "chainId": 1, "contractAddress": "0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2", - "nonce": 664, + "nonce": 663, } `, ) @@ -64,7 +83,7 @@ test('behavior: partial authorization: no nonce', async () => { { "chainId": 10, "contractAddress": "0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2", - "nonce": 664, + "nonce": 663, } `, ) @@ -88,31 +107,11 @@ test('behavior: partial authorization: no chainId', async () => { ) }) -test('behavior: sponsor is address', async () => { - const authorization = await prepareAuthorization(client, { - account, - contractAddress: wagmiContractConfig.address, - sponsor: '0x0000000000000000000000000000000000000000', - }) - - expect(authorization.nonce).toBe(663) -}) - -test('behavior: sponsor is truthy', async () => { - const authorization = await prepareAuthorization(client, { - account, - contractAddress: wagmiContractConfig.address, - sponsor: true, - }) - - expect(authorization.nonce).toBe(663) -}) - -test('behavior: account as sponsor', async () => { +test('behavior: self-executing', async () => { const authorization = await prepareAuthorization(client, { account, contractAddress: wagmiContractConfig.address, - sponsor: account, + executor: 'self', }) expect(authorization.nonce).toBe(664) @@ -168,7 +167,7 @@ test('error: no account', async () => { [AccountNotFoundError: Could not find an Account to execute with this Action. Please provide an Account with the \`account\` argument on the Action, or by supplying an \`account\` to the Client. - Docs: https://viem.sh/experimental/eip7702/prepareAuthorization + Docs: https://viem.sh/docs/eip7702/prepareAuthorization Version: viem@x.y.z] `) }) diff --git a/src/experimental/eip7702/actions/prepareAuthorization.ts b/src/actions/wallet/prepareAuthorization.ts similarity index 60% rename from src/experimental/eip7702/actions/prepareAuthorization.ts rename to src/actions/wallet/prepareAuthorization.ts index 324b0cbe9e..753af58d9b 100644 --- a/src/experimental/eip7702/actions/prepareAuthorization.ts +++ b/src/actions/wallet/prepareAuthorization.ts @@ -1,41 +1,35 @@ -import type { Address } from 'abitype' -import type { Account } from '../../../accounts/types.js' +import type { Account } from '../../accounts/types.js' import { type ParseAccountErrorType, parseAccount, -} from '../../../accounts/utils/parseAccount.js' -import { getChainId } from '../../../actions/public/getChainId.js' -import { getTransactionCount } from '../../../actions/public/getTransactionCount.js' -import type { Client } from '../../../clients/createClient.js' -import type { Transport } from '../../../clients/transports/createTransport.js' +} from '../../accounts/utils/parseAccount.js' +import type { Client } from '../../clients/createClient.js' +import type { Transport } from '../../clients/transports/createTransport.js' import { AccountNotFoundError, type AccountNotFoundErrorType, -} from '../../../errors/account.js' -import type { ErrorType } from '../../../errors/utils.js' -import type { GetAccountParameter } from '../../../types/account.js' -import type { Chain } from '../../../types/chain.js' -import type { PartialBy } from '../../../types/utils.js' -import { isAddressEqual } from '../../../utils/address/isAddressEqual.js' -import type { RequestErrorType } from '../../../utils/buildRequest.js' -import { getAction } from '../../../utils/getAction.js' -import type { Authorization } from '../types/authorization.js' +} from '../../errors/account.js' +import type { ErrorType } from '../../errors/utils.js' +import type { GetAccountParameter } from '../../types/account.js' +import type { Authorization } from '../../types/authorization.js' +import type { Chain } from '../../types/chain.js' +import type { PartialBy } from '../../types/utils.js' +import type { RequestErrorType } from '../../utils/buildRequest.js' +import { getAction } from '../../utils/getAction.js' +import { getChainId } from '../public/getChainId.js' +import { getTransactionCount } from '../public/getTransactionCount.js' export type PrepareAuthorizationParameters< account extends Account | undefined = Account | undefined, > = GetAccountParameter & PartialBy & { /** - * @deprecated Use `sponsor` instead. - */ - delegate?: true | Address | Account | undefined - /** - * Whether the EIP-7702 Transaction will be executed by another Account. + * Whether the EIP-7702 Transaction will be executed by the EOA (signing this Authorization) or another Account. * - * If not specified, it will be assumed that the EIP-7702 Transaction will - * be executed by the Account that signed the Authorization. + * By default, it will be assumed that the EIP-7702 Transaction will + * be executed by another Account. */ - sponsor?: true | Address | Account | undefined + executor?: 'self' | undefined } export type PrepareAuthorizationReturnType = Authorization @@ -50,7 +44,7 @@ export type PrepareAuthorizationErrorType = * Prepares an [EIP-7702 Authorization](https://eips.ethereum.org/EIPS/eip-7702) object for signing. * This Action will fill the required fields of the Authorization object if they are not provided (e.g. `nonce` and `chainId`). * - * With the prepared Authorization object, you can use [`signAuthorization`](https://viem.sh/experimental/eip7702/signAuthorization) to sign over the Authorization object. + * With the prepared Authorization object, you can use [`signAuthorization`](https://viem.sh/docs/eip7702/signAuthorization) to sign over the Authorization object. * * @param client - Client to use * @param parameters - {@link PrepareAuthorizationParameters} @@ -96,26 +90,19 @@ export async function prepareAuthorization< ): Promise { const { account: account_ = client.account, - contractAddress, chainId, + executor, nonce, } = parameters if (!account_) throw new AccountNotFoundError({ - docsPath: '/experimental/eip7702/prepareAuthorization', + docsPath: '/docs/eip7702/prepareAuthorization', }) const account = parseAccount(account_) - const sponsor = (() => { - const sponsor_ = parameters.sponsor ?? parameters.delegate - if (typeof sponsor_ === 'boolean') return sponsor_ - if (sponsor_) return parseAccount(sponsor_) - return undefined - })() - const authorization = { - contractAddress, + contractAddress: parameters.contractAddress ?? parameters.address, chainId, nonce, } as Authorization @@ -134,11 +121,7 @@ export async function prepareAuthorization< address: account.address, blockTag: 'pending', }) - if ( - !sponsor || - (sponsor !== true && isAddressEqual(account.address, sponsor.address)) - ) - authorization.nonce += 1 + if (executor === 'self') authorization.nonce += 1 } return authorization diff --git a/src/actions/wallet/prepareTransactionRequest.test.ts b/src/actions/wallet/prepareTransactionRequest.test.ts index 571649cd6e..0766974099 100644 --- a/src/actions/wallet/prepareTransactionRequest.test.ts +++ b/src/actions/wallet/prepareTransactionRequest.test.ts @@ -86,10 +86,10 @@ test('legacy fees', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -125,10 +125,10 @@ test('args: account', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -162,10 +162,10 @@ test('args: chain', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -200,10 +200,10 @@ test('args: chainId', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -235,10 +235,10 @@ test('args: nonce', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -273,10 +273,10 @@ test('args: gasPrice', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -310,10 +310,10 @@ test('args: gasPrice (on chain w/ block.baseFeePerGas)', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -344,10 +344,10 @@ test('args: maxFeePerGas', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -417,10 +417,10 @@ test('args: maxPriorityFeePerGas', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -452,10 +452,10 @@ test('args: maxPriorityFeePerGas === 0', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -509,10 +509,10 @@ test('args: maxFeePerGas + maxPriorityFeePerGas', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -581,10 +581,10 @@ test('args: type', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -622,10 +622,10 @@ test('args: blobs', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -665,10 +665,10 @@ test('args: parameters', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -692,10 +692,10 @@ test('args: parameters', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -722,10 +722,10 @@ test('args: parameters', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -753,10 +753,10 @@ test('args: parameters', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -801,10 +801,10 @@ test('args: parameters', async () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], diff --git a/src/actions/wallet/sendTransaction.test.ts b/src/actions/wallet/sendTransaction.test.ts index 23df01e739..5ed0e2f24c 100644 --- a/src/actions/wallet/sendTransaction.test.ts +++ b/src/actions/wallet/sendTransaction.test.ts @@ -17,7 +17,6 @@ import { InvalidInputRpcError, MethodNotSupportedRpcError, } from '../../errors/rpc.js' -import { signAuthorization } from '../../experimental/index.js' import type { Hex } from '../../types/misc.js' import type { TransactionSerializable } from '../../types/transaction.js' import { toBlobs } from '../../utils/blob/toBlobs.js' @@ -45,6 +44,7 @@ import { setBalance } from '../test/setBalance.js' import { setNextBlockBaseFeePerGas } from '../test/setNextBlockBaseFeePerGas.js' import { setNonce } from '../test/setNonce.js' import { sendTransaction } from './sendTransaction.js' +import { signAuthorization } from './signAuthorization.js' const client = anvilMainnet.getClient() const clientWithAccount = anvilMainnet.getClient({ @@ -903,76 +903,12 @@ describe('local account', () => { }) test('args: authorizationList', async () => { - const authority = privateKeyToAccount(accounts[9].privateKey) + const eoa = privateKeyToAccount(accounts[9].privateKey) + const relay = privateKeyToAccount(accounts[0].privateKey) const recipient = privateKeyToAccount(generatePrivateKey()) - const balance_recipient = await getBalance(client, { - address: recipient.address, - }) - - const { contractAddress } = await deploy(client, { - abi: BatchCallDelegation.abi, - bytecode: BatchCallDelegation.bytecode.object, - }) - - const authorization = await signAuthorization(client, { - account: authority, - contractAddress: contractAddress!, - }) - - const hash = await sendTransaction(client, { - account: authority, - authorizationList: [authorization], - data: encodeFunctionData({ - abi: BatchCallDelegation.abi, - functionName: 'execute', - args: [ - [ - { - to: recipient.address, - data: '0x', - value: parseEther('1'), - }, - ], - ], - }), - to: authority.address, - }) - expect(hash).toBeDefined() - - await mine(client, { blocks: 1 }) - - const receipt = await getTransactionReceipt(client, { hash }) - const log = receipt.logs[0] - expect(getAddress(log.address)).toBe(authority.address) - expect( - decodeEventLog({ - abi: BatchCallDelegation.abi, - ...log, - }), - ).toEqual({ - args: { - data: '0x', - to: recipient.address, - value: parseEther('1'), - }, - eventName: 'CallEmitted', - }) - - expect( - await getBalance(client, { - address: recipient.address, - }), - ).toBe(balance_recipient + parseEther('1')) - }) - - test('args: authorizationList (sponsor)', async () => { - const sponsor = privateKeyToAccount(accounts[0].privateKey) - const authority = privateKeyToAccount(accounts[9].privateKey) - const recipient = privateKeyToAccount(generatePrivateKey()) - - const balance_authority = await getBalance(client, { - address: authority.address, + const balance_eoa = await getBalance(client, { + address: eoa.address, }) const balance_recipient = await getBalance(client, { address: recipient.address, @@ -984,13 +920,12 @@ describe('local account', () => { }) const authorization = await signAuthorization(client, { - account: authority, + account: eoa, contractAddress: contractAddress!, - sponsor, }) const hash = await sendTransaction(client, { - account: sponsor, + account: relay, authorizationList: [authorization], data: encodeFunctionData({ abi: BatchCallDelegation.abi, @@ -1005,7 +940,7 @@ describe('local account', () => { ], ], }), - to: authority.address, + to: eoa.address, }) expect(hash).toBeDefined() @@ -1013,7 +948,7 @@ describe('local account', () => { const receipt = await getTransactionReceipt(client, { hash }) const log = receipt.logs[0] - expect(getAddress(log.address)).toBe(authority.address) + expect(getAddress(log.address)).toBe(eoa.address) expect( decodeEventLog({ abi: BatchCallDelegation.abi, @@ -1035,17 +970,17 @@ describe('local account', () => { ).toBe(balance_recipient + parseEther('1')) expect( await getBalance(client, { - address: authority.address, + address: eoa.address, }), - ).toBe(balance_authority - parseEther('1')) + ).toBe(balance_eoa - parseEther('1')) }) test('args: authorizationList (cross-chain)', async () => { - const sponsor = privateKeyToAccount(accounts[0].privateKey) - const authority = privateKeyToAccount(generatePrivateKey()) + const eoa = privateKeyToAccount(generatePrivateKey()) + const relay = privateKeyToAccount(accounts[0].privateKey) const recipient = privateKeyToAccount(generatePrivateKey()) - const client_sepolia = anvilSepolia.getClient({ account: sponsor }) + const client_sepolia = anvilSepolia.getClient({ account: relay }) // deploy on mainnet const { contractAddress, hash } = await deploy(client, { @@ -1056,7 +991,7 @@ describe('local account', () => { const { nonce } = await getTransaction(client, { hash }) // deploy on sepolia - await setNonce(client_sepolia, { address: sponsor.address, nonce }) + await setNonce(client_sepolia, { address: relay.address, nonce }) await deploy(client_sepolia, { abi: BatchCallDelegation.abi, bytecode: BatchCallDelegation.bytecode.object, @@ -1064,14 +999,13 @@ describe('local account', () => { // sign authorization with `0` chain id (all chains) const authorization = await signAuthorization(client, { - account: authority, + account: eoa, chainId: 0, contractAddress: contractAddress!, - sponsor, }) const args = { - account: sponsor, + account: relay, authorizationList: [authorization], data: encodeFunctionData({ abi: BatchCallDelegation.abi, @@ -1086,7 +1020,7 @@ describe('local account', () => { ], ], }), - to: authority.address, + to: eoa.address, } as const // execute transactions on mainnet and sepolia @@ -1108,6 +1042,71 @@ describe('local account', () => { expect(receipt_sepolia.logs.length).toBeGreaterThan(0) }) + test('args: authorizationList (self-executing)', async () => { + const eoa = privateKeyToAccount(accounts[9].privateKey) + const recipient = privateKeyToAccount(generatePrivateKey()) + + const balance_recipient = await getBalance(client, { + address: recipient.address, + }) + + const { contractAddress } = await deploy(client, { + abi: BatchCallDelegation.abi, + bytecode: BatchCallDelegation.bytecode.object, + }) + + const authorization = await signAuthorization(client, { + account: eoa, + contractAddress: contractAddress!, + executor: 'self', + }) + + const hash = await sendTransaction(client, { + account: eoa, + authorizationList: [authorization], + data: encodeFunctionData({ + abi: BatchCallDelegation.abi, + functionName: 'execute', + args: [ + [ + { + to: recipient.address, + data: '0x', + value: parseEther('1'), + }, + ], + ], + }), + to: eoa.address, + }) + expect(hash).toBeDefined() + + await mine(client, { blocks: 1 }) + + const receipt = await getTransactionReceipt(client, { hash }) + const log = receipt.logs[0] + expect(getAddress(log.address)).toBe(eoa.address) + expect( + decodeEventLog({ + abi: BatchCallDelegation.abi, + ...log, + }), + ).toEqual({ + args: { + data: '0x', + to: recipient.address, + value: parseEther('1'), + }, + eventName: 'CallEmitted', + }) + + expect( + await getBalance(client, { + address: recipient.address, + }), + ).toBe(balance_recipient + parseEther('1')) + }) + test('args: blobs', async () => { const blobs = toBlobs({ data: stringToHex(blobData), @@ -1544,16 +1543,16 @@ describe('errors', () => { }) test('https://github.com/wevm/viem/issues/2721', async () => { - const sponsor = privateKeyToAccount(generatePrivateKey()) - const authority = privateKeyToAccount(generatePrivateKey()) + const relay = privateKeyToAccount(generatePrivateKey()) + const eoa = privateKeyToAccount(generatePrivateKey()) const recipient = privateKeyToAccount(generatePrivateKey()) await setBalance(client, { - address: sponsor.address, + address: relay.address, value: parseEther('100'), }) await setBalance(client, { - address: authority.address, + address: eoa.address, value: parseEther('100'), }) @@ -1563,12 +1562,12 @@ test('https://github.com/wevm/viem/issues/2721', async () => { }) const authorization = await signAuthorization(client, { - account: authority, + account: eoa, contractAddress: contractAddress!, }) const hash = await sendTransaction(client, { - account: sponsor, + account: relay, authorizationList: [authorization], data: encodeFunctionData({ abi: BatchCallDelegation.abi, @@ -1583,7 +1582,7 @@ test('https://github.com/wevm/viem/issues/2721', async () => { ], ], }), - to: authority.address, + to: eoa.address, }) expect(hash).toBeDefined() }) diff --git a/src/actions/wallet/sendTransaction.ts b/src/actions/wallet/sendTransaction.ts index 0f9f452523..46aac2b4af 100644 --- a/src/actions/wallet/sendTransaction.ts +++ b/src/actions/wallet/sendTransaction.ts @@ -16,10 +16,6 @@ import { } from '../../errors/account.js' import { BaseError } from '../../errors/base.js' import type { ErrorType } from '../../errors/utils.js' -import { - type RecoverAuthorizationAddressErrorType, - recoverAuthorizationAddress, -} from '../../experimental/eip7702/utils/recoverAuthorizationAddress.js' import type { GetAccountParameter } from '../../types/account.js' import type { Chain, DeriveChain } from '../../types/chain.js' import type { GetChainParameter } from '../../types/chain.js' @@ -27,6 +23,10 @@ import type { GetTransactionRequestKzgParameter } from '../../types/kzg.js' import type { Hash } from '../../types/misc.js' import type { TransactionRequest } from '../../types/transaction.js' import type { UnionOmit } from '../../types/utils.js' +import { + type RecoverAuthorizationAddressErrorType, + recoverAuthorizationAddress, +} from '../../utils/authorization/recoverAuthorizationAddress.js' import type { RequestErrorType } from '../../utils/buildRequest.js' import { type AssertCurrentChainErrorType, diff --git a/src/experimental/eip7702/actions/signAuthorization.test.ts b/src/actions/wallet/signAuthorization.test.ts similarity index 86% rename from src/experimental/eip7702/actions/signAuthorization.test.ts rename to src/actions/wallet/signAuthorization.test.ts index 9334b2b32c..7dc8beb341 100644 --- a/src/experimental/eip7702/actions/signAuthorization.test.ts +++ b/src/actions/wallet/signAuthorization.test.ts @@ -1,10 +1,10 @@ import { beforeAll, expect, test } from 'vitest' -import { wagmiContractConfig } from '../../../../test/src/abis.js' -import { anvilMainnet } from '../../../../test/src/anvil.js' -import { accounts } from '../../../../test/src/constants.js' -import { privateKeyToAccount } from '../../../accounts/privateKeyToAccount.js' -import { reset } from '../../../actions/index.js' -import { verifyAuthorization } from '../utils/verifyAuthorization.js' +import { wagmiContractConfig } from '../../../test/src/abis.js' +import { anvilMainnet } from '../../../test/src/anvil.js' +import { accounts } from '../../../test/src/constants.js' +import { privateKeyToAccount } from '../../accounts/privateKeyToAccount.js' +import { verifyAuthorization } from '../../utils/authorization/verifyAuthorization.js' +import { reset } from '../index.js' import { signAuthorization } from './signAuthorization.js' const account = privateKeyToAccount(accounts[0].privateKey) @@ -56,6 +56,41 @@ test('default', async () => { ).toBe(true) }) +test('args: address (alias)', async () => { + const authorization = await signAuthorization(client, { + account, + address: wagmiContractConfig.address, + chainId: 1, + nonce: 0, + }) + + expect({ + ...authorization, + r: null, + s: null, + v: null, + yParity: null, + }).toMatchInlineSnapshot( + ` + { + "chainId": 1, + "contractAddress": "0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2", + "nonce": 0, + "r": null, + "s": null, + "v": null, + "yParity": null, + } + `, + ) + expect( + await verifyAuthorization({ + address: account.address, + authorization, + }), + ).toBe(true) +}) + test('behavior: address as authorization', async () => { const authorization = await signAuthorization(client, { account, @@ -73,7 +108,7 @@ test('behavior: address as authorization', async () => { { "chainId": 1, "contractAddress": "0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2", - "nonce": 664, + "nonce": 663, "r": null, "s": null, "v": null, @@ -110,7 +145,7 @@ test('behavior: partial authorization: no chainId + nonce', async () => { { "chainId": 1, "contractAddress": "0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2", - "nonce": 664, + "nonce": 663, "r": null, "s": null, "v": null, @@ -148,7 +183,7 @@ test('behavior: partial authorization: no nonce', async () => { { "chainId": 10, "contractAddress": "0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2", - "nonce": 664, + "nonce": 663, "r": null, "s": null, "v": null, @@ -206,43 +241,11 @@ test('behavior: partial authorization: no chainId', async () => { ).toBe(true) }) -test('behavior: sponsor is address', async () => { - const authorization = await signAuthorization(client, { - account, - contractAddress: wagmiContractConfig.address, - sponsor: '0x0000000000000000000000000000000000000000', - }) - - expect(authorization.nonce).toBe(663) - expect( - await verifyAuthorization({ - address: account.address, - authorization, - }), - ).toBe(true) -}) - -test('behavior: sponsor is truthy', async () => { - const authorization = await signAuthorization(client, { - account, - contractAddress: wagmiContractConfig.address, - sponsor: true, - }) - - expect(authorization.nonce).toBe(663) - expect( - await verifyAuthorization({ - address: account.address, - authorization, - }), - ).toBe(true) -}) - -test('behavior: account as sponsor', async () => { +test('behavior: self-executing', async () => { const authorization = await signAuthorization(client, { account, contractAddress: wagmiContractConfig.address, - sponsor: account, + executor: 'self', }) expect(authorization.nonce).toBe(664) @@ -345,7 +348,7 @@ test('error: unsupported account type', async () => { The \`signAuthorization\` Action does not support JSON-RPC Accounts. - Docs: https://viem.sh/experimental/eip7702/signAuthorization + Docs: https://viem.sh/docs/eip7702/signAuthorization Version: viem@x.y.z] `) }) @@ -362,7 +365,7 @@ test('error: no account', async () => { [AccountNotFoundError: Could not find an Account to execute with this Action. Please provide an Account with the \`account\` argument on the Action, or by supplying an \`account\` to the Client. - Docs: https://viem.sh/experimental/eip7702/signAuthorization + Docs: https://viem.sh/docs/eip7702/signAuthorization Version: viem@x.y.z] `) }) diff --git a/src/experimental/eip7702/actions/signAuthorization.ts b/src/actions/wallet/signAuthorization.ts similarity index 74% rename from src/experimental/eip7702/actions/signAuthorization.ts rename to src/actions/wallet/signAuthorization.ts index 1306c694f4..b10423212a 100644 --- a/src/experimental/eip7702/actions/signAuthorization.ts +++ b/src/actions/wallet/signAuthorization.ts @@ -1,22 +1,22 @@ -import type { Account } from '../../../accounts/types.js' +import type { Account } from '../../accounts/types.js' import { type ParseAccountErrorType, parseAccount, -} from '../../../accounts/utils/parseAccount.js' +} from '../../accounts/utils/parseAccount.js' import type { SignAuthorizationErrorType as SignAuthorizationErrorType_account, SignAuthorizationReturnType as SignAuthorizationReturnType_account, -} from '../../../accounts/utils/signAuthorization.js' -import type { Client } from '../../../clients/createClient.js' -import type { Transport } from '../../../clients/transports/createTransport.js' +} from '../../accounts/utils/signAuthorization.js' +import type { Client } from '../../clients/createClient.js' +import type { Transport } from '../../clients/transports/createTransport.js' import { AccountNotFoundError, type AccountNotFoundErrorType, AccountTypeNotSupportedError, type AccountTypeNotSupportedErrorType, -} from '../../../errors/account.js' -import type { ErrorType } from '../../../errors/utils.js' -import type { Chain } from '../../../types/chain.js' +} from '../../errors/account.js' +import type { ErrorType } from '../../errors/utils.js' +import type { Chain } from '../../types/chain.js' import { type PrepareAuthorizationErrorType, type PrepareAuthorizationParameters, @@ -41,8 +41,8 @@ export type SignAuthorizationErrorType = * Signs an [EIP-7702 Authorization](https://eips.ethereum.org/EIPS/eip-7702) object. * * With the calculated signature, you can: - * - use [`verifyAuthorization`](https://viem.sh/experimental/eip7702/verifyAuthorization) to verify the signed Authorization object, - * - use [`recoverAuthorizationAddress`](https://viem.sh/experimental/eip7702/recoverAuthorizationAddress) to recover the signing address from the signed Authorization object. + * - use [`verifyAuthorization`](https://viem.sh/docs/eip7702/verifyAuthorization) to verify the signed Authorization object, + * - use [`recoverAuthorizationAddress`](https://viem.sh/docs/eip7702/recoverAuthorizationAddress) to recover the signing address from the signed Authorization object. * * @param client - Client to use * @param parameters - {@link SignAuthorizationParameters} @@ -90,13 +90,13 @@ export async function signAuthorization< if (!account_) throw new AccountNotFoundError({ - docsPath: '/experimental/eip7702/signAuthorization', + docsPath: '/docs/eip7702/signAuthorization', }) const account = parseAccount(account_) - if (!account.experimental_signAuthorization) + if (!account.signAuthorization) throw new AccountTypeNotSupportedError({ - docsPath: '/experimental/eip7702/signAuthorization', + docsPath: '/docs/eip7702/signAuthorization', metaMessages: [ 'The `signAuthorization` Action does not support JSON-RPC Accounts.', ], @@ -104,5 +104,5 @@ export async function signAuthorization< }) const authorization = await prepareAuthorization(client, parameters) - return account.experimental_signAuthorization(authorization) + return account.signAuthorization(authorization) } diff --git a/src/actions/wallet/signTransaction.test.ts b/src/actions/wallet/signTransaction.test.ts index f0110c4fbb..e156803120 100644 --- a/src/actions/wallet/signTransaction.test.ts +++ b/src/actions/wallet/signTransaction.test.ts @@ -36,8 +36,8 @@ const base = { } satisfies TransactionRequestBase describe('eip7702', async () => { - const authority = privateKeyToAccount(accounts[1].privateKey) - const authorization = await authority.experimental_signAuthorization({ + const eoa = privateKeyToAccount(accounts[1].privateKey) + const authorization = await eoa.signAuthorization({ contractAddress: wagmiContractConfig.address, chainId: 1, nonce: 420, diff --git a/src/actions/wallet/writeContract.test.ts b/src/actions/wallet/writeContract.test.ts index 68f096c0fd..df559b53a9 100644 --- a/src/actions/wallet/writeContract.test.ts +++ b/src/actions/wallet/writeContract.test.ts @@ -16,13 +16,13 @@ import { createWalletClient } from '../../clients/createWalletClient.js' import { walletActions } from '../../clients/decorators/wallet.js' import { http } from '../../clients/transports/http.js' import { InvalidInputRpcError } from '../../errors/rpc.js' -import { signAuthorization } from '../../experimental/index.js' import { decodeEventLog, getAddress, parseEther } from '../../utils/index.js' import { getBalance } from '../public/getBalance.js' import { getTransaction } from '../public/getTransaction.js' import { getTransactionReceipt } from '../public/getTransactionReceipt.js' import { simulateContract } from '../public/simulateContract.js' import { mine } from '../test/mine.js' +import { signAuthorization } from './signAuthorization.js' import { writeContract } from './writeContract.js' const client = anvilMainnet.getClient().extend(walletActions) @@ -159,9 +159,13 @@ describe('args: chain', () => { }) test('args: authorizationList', async () => { - const authority = privateKeyToAccount(accounts[1].privateKey) + const eoa = privateKeyToAccount(accounts[1].privateKey) + const relay = privateKeyToAccount(accounts[0].privateKey) const recipient = privateKeyToAccount(generatePrivateKey()) + const balance_eoa = await getBalance(client, { + address: eoa.address, + }) const balance_recipient = await getBalance(client, { address: recipient.address, }) @@ -172,14 +176,14 @@ test('args: authorizationList', async () => { }) const authorization = await signAuthorization(client, { - account: authority, + account: eoa, contractAddress: contractAddress!, }) const hash = await writeContract(client, { abi: BatchCallDelegation.abi, - account: authority, - address: authority.address, + account: relay, + address: eoa.address, authorizationList: [authorization], functionName: 'execute', args: [ @@ -198,7 +202,7 @@ test('args: authorizationList', async () => { const receipt = await getTransactionReceipt(client, { hash }) const log = receipt.logs[0] - expect(getAddress(log.address)).toBe(authority.address) + expect(getAddress(log.address)).toBe(eoa.address) expect( decodeEventLog({ abi: BatchCallDelegation.abi, @@ -218,16 +222,17 @@ test('args: authorizationList', async () => { address: recipient.address, }), ).toBe(balance_recipient + parseEther('1')) + expect( + await getBalance(client, { + address: eoa.address, + }), + ).toBe(balance_eoa - parseEther('1')) }) -test('args: authorizationList (sponsor)', async () => { - const sponsor = privateKeyToAccount(accounts[0].privateKey) - const authority = privateKeyToAccount(accounts[1].privateKey) +test('args: authorizationList (self-executing)', async () => { + const eoa = privateKeyToAccount(accounts[1].privateKey) const recipient = privateKeyToAccount(generatePrivateKey()) - const balance_authority = await getBalance(client, { - address: authority.address, - }) const balance_recipient = await getBalance(client, { address: recipient.address, }) @@ -238,15 +243,15 @@ test('args: authorizationList (sponsor)', async () => { }) const authorization = await signAuthorization(client, { - account: authority, + account: eoa, contractAddress: contractAddress!, - sponsor, + executor: 'self', }) const hash = await writeContract(client, { abi: BatchCallDelegation.abi, - account: sponsor, - address: authority.address, + account: eoa, + address: eoa.address, authorizationList: [authorization], functionName: 'execute', args: [ @@ -265,7 +270,7 @@ test('args: authorizationList (sponsor)', async () => { const receipt = await getTransactionReceipt(client, { hash }) const log = receipt.logs[0] - expect(getAddress(log.address)).toBe(authority.address) + expect(getAddress(log.address)).toBe(eoa.address) expect( decodeEventLog({ abi: BatchCallDelegation.abi, @@ -285,11 +290,6 @@ test('args: authorizationList (sponsor)', async () => { address: recipient.address, }), ).toBe(balance_recipient + parseEther('1')) - expect( - await getBalance(client, { - address: authority.address, - }), - ).toBe(balance_authority - parseEther('1')) }) test('args: dataSuffix', async () => { diff --git a/src/clients/createPublicClient.test.ts b/src/clients/createPublicClient.test.ts index ab32542685..79c835afe1 100644 --- a/src/clients/createPublicClient.test.ts +++ b/src/clients/createPublicClient.test.ts @@ -538,6 +538,7 @@ test('extend', () => { "multicall": [Function], "name": "Public Client", "pollingInterval": 4000, + "prepareAuthorization": [Function], "prepareTransactionRequest": [Function], "readContract": [Function], "removeBlockTimestampInterval": [Function], @@ -563,6 +564,7 @@ test('extend', () => { "setNonce": [Function], "setRpcUrl": [Function], "setStorageAt": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], diff --git a/src/clients/createTestClient.test.ts b/src/clients/createTestClient.test.ts index f1d0c20d22..d1d7c15402 100644 --- a/src/clients/createTestClient.test.ts +++ b/src/clients/createTestClient.test.ts @@ -373,6 +373,7 @@ test('extend', () => { "multicall": [Function], "name": "Test Client", "pollingInterval": 4000, + "prepareAuthorization": [Function], "prepareTransactionRequest": [Function], "readContract": [Function], "removeBlockTimestampInterval": [Function], @@ -398,6 +399,7 @@ test('extend', () => { "setNonce": [Function], "setRpcUrl": [Function], "setStorageAt": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], diff --git a/src/clients/createWalletClient.test.ts b/src/clients/createWalletClient.test.ts index 45cd0eb987..538d32bb8d 100644 --- a/src/clients/createWalletClient.test.ts +++ b/src/clients/createWalletClient.test.ts @@ -48,12 +48,14 @@ test('creates', () => { "key": "wallet", "name": "Wallet Client", "pollingInterval": 4000, + "prepareAuthorization": [Function], "prepareTransactionRequest": [Function], "request": [Function], "requestAddresses": [Function], "requestPermissions": [Function], "sendRawTransaction": [Function], "sendTransaction": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -104,12 +106,14 @@ describe('args: account', () => { "key": "wallet", "name": "Wallet Client", "pollingInterval": 4000, + "prepareAuthorization": [Function], "prepareTransactionRequest": [Function], "request": [Function], "requestAddresses": [Function], "requestPermissions": [Function], "sendRawTransaction": [Function], "sendTransaction": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -144,10 +148,10 @@ describe('args: account', () => { { "account": { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": [Function], "nonceManager": undefined, "publicKey": "0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5", "sign": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -167,12 +171,14 @@ describe('args: account', () => { "key": "wallet", "name": "Wallet Client", "pollingInterval": 4000, + "prepareAuthorization": [Function], "prepareTransactionRequest": [Function], "request": [Function], "requestAddresses": [Function], "requestPermissions": [Function], "sendRawTransaction": [Function], "sendTransaction": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -218,12 +224,14 @@ describe('args: transport', () => { "key": "wallet", "name": "Wallet Client", "pollingInterval": 4000, + "prepareAuthorization": [Function], "prepareTransactionRequest": [Function], "request": [Function], "requestAddresses": [Function], "requestPermissions": [Function], "sendRawTransaction": [Function], "sendTransaction": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -267,12 +275,14 @@ describe('args: transport', () => { "key": "wallet", "name": "Wallet Client", "pollingInterval": 4000, + "prepareAuthorization": [Function], "prepareTransactionRequest": [Function], "request": [Function], "requestAddresses": [Function], "requestPermissions": [Function], "sendRawTransaction": [Function], "sendTransaction": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -337,12 +347,14 @@ describe('args: transport', () => { "key": "wallet", "name": "Wallet Client", "pollingInterval": 4000, + "prepareAuthorization": [Function], "prepareTransactionRequest": [Function], "request": [Function], "requestAddresses": [Function], "requestPermissions": [Function], "sendRawTransaction": [Function], "sendTransaction": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], @@ -460,6 +472,7 @@ test('extend', () => { "multicall": [Function], "name": "Wallet Client", "pollingInterval": 4000, + "prepareAuthorization": [Function], "prepareTransactionRequest": [Function], "readContract": [Function], "removeBlockTimestampInterval": [Function], @@ -485,6 +498,7 @@ test('extend', () => { "setNonce": [Function], "setRpcUrl": [Function], "setStorageAt": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], diff --git a/src/clients/decorators/wallet.test.ts b/src/clients/decorators/wallet.test.ts index 46e248802e..0f36be2a25 100644 --- a/src/clients/decorators/wallet.test.ts +++ b/src/clients/decorators/wallet.test.ts @@ -22,11 +22,13 @@ test('default', async () => { "getAddresses": [Function], "getChainId": [Function], "getPermissions": [Function], + "prepareAuthorization": [Function], "prepareTransactionRequest": [Function], "requestAddresses": [Function], "requestPermissions": [Function], "sendRawTransaction": [Function], "sendTransaction": [Function], + "signAuthorization": [Function], "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], diff --git a/src/clients/decorators/wallet.ts b/src/clients/decorators/wallet.ts index 2103bd93f0..fbb1b6962e 100644 --- a/src/clients/decorators/wallet.ts +++ b/src/clients/decorators/wallet.ts @@ -22,6 +22,11 @@ import { type GetPermissionsReturnType, getPermissions, } from '../../actions/wallet/getPermissions.js' +import { + type PrepareAuthorizationParameters, + type PrepareAuthorizationReturnType, + prepareAuthorization, +} from '../../actions/wallet/prepareAuthorization.js' import { type PrepareTransactionRequestParameters, type PrepareTransactionRequestRequest, @@ -48,6 +53,11 @@ import { type SendTransactionReturnType, sendTransaction, } from '../../actions/wallet/sendTransaction.js' +import { + type SignAuthorizationParameters, + type SignAuthorizationReturnType, + signAuthorization, +} from '../../actions/wallet/signAuthorization.js' import { type SignMessageParameters, type SignMessageReturnType, @@ -197,6 +207,52 @@ export type WalletActions< * const permissions = await client.getPermissions() */ getPermissions: () => Promise + /** + * Prepares an [EIP-7702 Authorization](https://eips.ethereum.org/EIPS/eip-7702) object for signing. + * This Action will fill the required fields of the Authorization object if they are not provided (e.g. `nonce` and `chainId`). + * + * With the prepared Authorization object, you can use [`signAuthorization`](https://viem.sh/docs/eip7702/signAuthorization) to sign over the Authorization object. + * + * @param client - Client to use + * @param parameters - {@link PrepareAuthorizationParameters} + * @returns The prepared Authorization object. {@link PrepareAuthorizationReturnType} + * + * @example + * import { createClient, http } from 'viem' + * import { privateKeyToAccount } from 'viem/accounts' + * import { mainnet } from 'viem/chains' + * import { eip7702Actions } from 'viem/experimental' + * + * const client = createClient({ + * chain: mainnet, + * transport: http(), + * }).extend(eip7702Actions()) + * + * const authorization = await client.prepareAuthorization({ + * account: privateKeyToAccount('0x..'), + * contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', + * }) + * + * @example + * // Account Hoisting + * import { createClient, http } from 'viem' + * import { privateKeyToAccount } from 'viem/accounts' + * import { mainnet } from 'viem/chains' + * import { eip7702Actions } from 'viem/experimental' + * + * const client = createClient({ + * account: privateKeyToAccount('0x…'), + * chain: mainnet, + * transport: http(), + * }).extend(eip7702Actions()) + * + * const authorization = await client.prepareAuthorization({ + * contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', + * }) + */ + prepareAuthorization: ( + parameters: PrepareAuthorizationParameters, + ) => Promise /** * Prepares a transaction request for signing. * @@ -381,6 +437,53 @@ export type WalletActions< >( args: SendTransactionParameters, ) => Promise + /** + * Signs an [EIP-7702 Authorization](https://eips.ethereum.org/EIPS/eip-7702) object. + * + * With the calculated signature, you can: + * - use [`verifyAuthorization`](https://viem.sh/docs/eip7702/verifyAuthorization) to verify the signed Authorization object, + * - use [`recoverAuthorizationAddress`](https://viem.sh/docs/eip7702/recoverAuthorizationAddress) to recover the signing address from the signed Authorization object. + * + * @param client - Client to use + * @param parameters - {@link SignAuthorizationParameters} + * @returns The signed Authorization object. {@link SignAuthorizationReturnType} + * + * @example + * import { createClient, http } from 'viem' + * import { privateKeyToAccount } from 'viem/accounts' + * import { mainnet } from 'viem/chains' + * import { eip7702Actions } from 'viem/experimental' + * + * const client = createClient({ + * chain: mainnet, + * transport: http(), + * }).extend(eip7702Actions()) + * + * const signature = await client.signAuthorization({ + * account: privateKeyToAccount('0x..'), + * contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', + * }) + * + * @example + * // Account Hoisting + * import { createClient, http } from 'viem' + * import { privateKeyToAccount } from 'viem/accounts' + * import { mainnet } from 'viem/chains' + * import { eip7702Actions } from 'viem/experimental' + * + * const client = createClient({ + * account: privateKeyToAccount('0x…'), + * chain: mainnet, + * transport: http(), + * }).extend(eip7702Actions()) + * + * const signature = await client.signAuthorization({ + * contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', + * }) + */ + signAuthorization: ( + parameters: SignAuthorizationParameters, + ) => Promise /** * Calculates an Ethereum-specific signature in [EIP-191 format](https://eips.ethereum.org/EIPS/eip-191): `keccak256("\x19Ethereum Signed Message:\n" + len(message) + message))`. * @@ -706,12 +809,14 @@ export function walletActions< getAddresses: () => getAddresses(client), getChainId: () => getChainId(client), getPermissions: () => getPermissions(client), + prepareAuthorization: (args) => prepareAuthorization(client, args), prepareTransactionRequest: (args) => prepareTransactionRequest(client as any, args as any) as any, requestAddresses: () => requestAddresses(client), requestPermissions: (args) => requestPermissions(client, args), sendRawTransaction: (args) => sendRawTransaction(client, args), sendTransaction: (args) => sendTransaction(client, args), + signAuthorization: (args) => signAuthorization(client, args), signMessage: (args) => signMessage(client, args), signTransaction: (args) => signTransaction(client, args), signTypedData: (args) => signTypedData(client, args), diff --git a/src/experimental/eip7702/decorators/eip7702.test.ts b/src/experimental/eip7702/decorators/eip7702.test.ts deleted file mode 100644 index 3200a2a3f6..0000000000 --- a/src/experimental/eip7702/decorators/eip7702.test.ts +++ /dev/null @@ -1,27 +0,0 @@ -import { describe, expect, test } from 'vitest' - -import { anvilMainnet } from '../../../../test/src/anvil.js' -import { accounts } from '../../../../test/src/constants.js' -import { privateKeyToAccount } from '../../../accounts/privateKeyToAccount.js' -import { eip7702Actions } from './eip7702.js' - -const client = anvilMainnet - .getClient({ account: privateKeyToAccount(accounts[0].privateKey) }) - .extend(eip7702Actions()) - -test('default', async () => { - expect(eip7702Actions()(client)).toMatchInlineSnapshot(` - { - "prepareAuthorization": [Function], - "signAuthorization": [Function], - } - `) -}) - -describe('smoke test', () => { - test('getCapabilities', async () => { - await client.signAuthorization({ - contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', - }) - }) -}) diff --git a/src/experimental/eip7702/decorators/eip7702.ts b/src/experimental/eip7702/decorators/eip7702.ts deleted file mode 100644 index 88cc1bf347..0000000000 --- a/src/experimental/eip7702/decorators/eip7702.ts +++ /dev/null @@ -1,139 +0,0 @@ -import type { Client } from '../../../clients/createClient.js' -import type { Transport } from '../../../clients/transports/createTransport.js' -import type { Account } from '../../../types/account.js' -import type { Chain } from '../../../types/chain.js' -import { - type PrepareAuthorizationParameters, - type PrepareAuthorizationReturnType, - prepareAuthorization, -} from '../actions/prepareAuthorization.js' -import { - type SignAuthorizationParameters, - type SignAuthorizationReturnType, - signAuthorization, -} from '../actions/signAuthorization.js' - -export type Eip7702Actions< - account extends Account | undefined = Account | undefined, -> = { - /** - * Prepares an [EIP-7702 Authorization](https://eips.ethereum.org/EIPS/eip-7702) object for signing. - * This Action will fill the required fields of the Authorization object if they are not provided (e.g. `nonce` and `chainId`). - * - * With the prepared Authorization object, you can use [`signAuthorization`](https://viem.sh/experimental/eip7702/signAuthorization) to sign over the Authorization object. - * - * @param client - Client to use - * @param parameters - {@link PrepareAuthorizationParameters} - * @returns The prepared Authorization object. {@link PrepareAuthorizationReturnType} - * - * @example - * import { createClient, http } from 'viem' - * import { privateKeyToAccount } from 'viem/accounts' - * import { mainnet } from 'viem/chains' - * import { eip7702Actions } from 'viem/experimental' - * - * const client = createClient({ - * chain: mainnet, - * transport: http(), - * }).extend(eip7702Actions()) - * - * const authorization = await client.prepareAuthorization({ - * account: privateKeyToAccount('0x..'), - * contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', - * }) - * - * @example - * // Account Hoisting - * import { createClient, http } from 'viem' - * import { privateKeyToAccount } from 'viem/accounts' - * import { mainnet } from 'viem/chains' - * import { eip7702Actions } from 'viem/experimental' - * - * const client = createClient({ - * account: privateKeyToAccount('0x…'), - * chain: mainnet, - * transport: http(), - * }).extend(eip7702Actions()) - * - * const authorization = await client.prepareAuthorization({ - * contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', - * }) - */ - prepareAuthorization: ( - parameters: PrepareAuthorizationParameters, - ) => Promise - /** - * Signs an [EIP-7702 Authorization](https://eips.ethereum.org/EIPS/eip-7702) object. - * - * With the calculated signature, you can: - * - use [`verifyAuthorization`](https://viem.sh/experimental/eip7702/verifyAuthorization) to verify the signed Authorization object, - * - use [`recoverAuthorizationAddress`](https://viem.sh/experimental/eip7702/recoverAuthorizationAddress) to recover the signing address from the signed Authorization object. - * - * @param client - Client to use - * @param parameters - {@link SignAuthorizationParameters} - * @returns The signed Authorization object. {@link SignAuthorizationReturnType} - * - * @example - * import { createClient, http } from 'viem' - * import { privateKeyToAccount } from 'viem/accounts' - * import { mainnet } from 'viem/chains' - * import { eip7702Actions } from 'viem/experimental' - * - * const client = createClient({ - * chain: mainnet, - * transport: http(), - * }).extend(eip7702Actions()) - * - * const signature = await client.signAuthorization({ - * account: privateKeyToAccount('0x..'), - * contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', - * }) - * - * @example - * // Account Hoisting - * import { createClient, http } from 'viem' - * import { privateKeyToAccount } from 'viem/accounts' - * import { mainnet } from 'viem/chains' - * import { eip7702Actions } from 'viem/experimental' - * - * const client = createClient({ - * account: privateKeyToAccount('0x…'), - * chain: mainnet, - * transport: http(), - * }).extend(eip7702Actions()) - * - * const signature = await client.signAuthorization({ - * contractAddress: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', - * }) - */ - signAuthorization: ( - parameters: SignAuthorizationParameters, - ) => Promise -} - -/** - * A suite of EIP-7702 Actions. - * - * @example - * import { createClient, http } from 'viem' - * import { mainnet } from 'viem/chains' - * import { eip7702Actions } from 'viem/experimental' - * - * const client = createClient({ - * chain: mainnet, - * transport: http(), - * }).extend(eip7702Actions()) - * - * const hash = await client.signAuthorization({ ... }) - */ -export function eip7702Actions() { - return ( - client: Client, - ): Eip7702Actions => { - return { - prepareAuthorization: (parameters) => - prepareAuthorization(client, parameters), - signAuthorization: (parameters) => signAuthorization(client, parameters), - } - } -} diff --git a/src/experimental/eip7702/types/rpc.ts b/src/experimental/eip7702/types/rpc.ts deleted file mode 100644 index 44984f4de5..0000000000 --- a/src/experimental/eip7702/types/rpc.ts +++ /dev/null @@ -1,18 +0,0 @@ -import type { Address } from 'abitype' -import type { Hex } from '../../../types/misc.js' - -export type RpcAuthorization = { - /** Address of the contract to set as code for the Authority. */ - address: Address - /** Chain ID to authorize. */ - chainId: Hex - /** Nonce of the Authority to authorize. */ - nonce: Hex - /** ECDSA r value. */ - r: Hex - /** ECDSA s value. */ - s: Hex - /** y parity. */ - yParity: Hex -} -export type RpcAuthorizationList = readonly RpcAuthorization[] diff --git a/src/experimental/erc7821/actions/execute.test.ts b/src/experimental/erc7821/actions/execute.test.ts index 34db120e84..2ab218601e 100644 --- a/src/experimental/erc7821/actions/execute.test.ts +++ b/src/experimental/erc7821/actions/execute.test.ts @@ -13,9 +13,9 @@ import { getTransactionReceipt, mine, readContract, + signAuthorization, } from '../../../actions/index.js' import { decodeEventLog, parseEther } from '../../../utils/index.js' -import { signAuthorization } from '../../eip7702/actions/signAuthorization.js' import { execute } from './execute.js' const client = anvilMainnet.getClient({ @@ -42,6 +42,7 @@ test('default', async () => { const authorization = await signAuthorization(client, { contractAddress: contractAddress!, + executor: 'self', }) await execute(client, { authorizationList: [authorization], diff --git a/src/experimental/erc7821/actions/executeBatches.test.ts b/src/experimental/erc7821/actions/executeBatches.test.ts index e0c109de67..caf59ea175 100644 --- a/src/experimental/erc7821/actions/executeBatches.test.ts +++ b/src/experimental/erc7821/actions/executeBatches.test.ts @@ -13,9 +13,9 @@ import { getTransactionReceipt, mine, readContract, + signAuthorization, } from '../../../actions/index.js' import { decodeEventLog, parseEther } from '../../../utils/index.js' -import { signAuthorization } from '../../eip7702/actions/signAuthorization.js' import { executeBatches } from './executeBatches.js' const client = anvilMainnet.getClient({ @@ -42,6 +42,7 @@ test('default', async () => { const authorization = await signAuthorization(client, { contractAddress: contractAddress!, + executor: 'self', }) await executeBatches(client, { authorizationList: [authorization], diff --git a/src/experimental/erc7821/actions/supportsExecutionMode.test.ts b/src/experimental/erc7821/actions/supportsExecutionMode.test.ts index 140e60e3ba..fcb1b6aa86 100644 --- a/src/experimental/erc7821/actions/supportsExecutionMode.test.ts +++ b/src/experimental/erc7821/actions/supportsExecutionMode.test.ts @@ -4,8 +4,11 @@ import { anvilMainnet } from '../../../../test/src/anvil.js' import { accounts } from '../../../../test/src/constants.js' import { deploy } from '../../../../test/src/utils.js' import { privateKeyToAccount } from '../../../accounts/privateKeyToAccount.js' -import { mine, sendTransaction } from '../../../actions/index.js' -import { signAuthorization } from '../../eip7702/actions/signAuthorization.js' +import { + mine, + sendTransaction, + signAuthorization, +} from '../../../actions/index.js' import { supportsExecutionMode } from './supportsExecutionMode.js' const client = anvilMainnet.getClient({ @@ -31,6 +34,7 @@ test('default', async () => { const authorization = await signAuthorization(client, { contractAddress: contractAddress!, + executor: 'self', }) await sendTransaction(client, { authorizationList: [authorization], diff --git a/src/experimental/erc7821/decorators/erc7821.test.ts b/src/experimental/erc7821/decorators/erc7821.test.ts index efcbcb9b6f..c27e2a2d81 100644 --- a/src/experimental/erc7821/decorators/erc7821.test.ts +++ b/src/experimental/erc7821/decorators/erc7821.test.ts @@ -5,8 +5,7 @@ import { anvilMainnet } from '../../../../test/src/anvil.js' import { accounts } from '../../../../test/src/constants.js' import { deploy } from '../../../../test/src/utils.js' import { privateKeyToAccount } from '../../../accounts/privateKeyToAccount.js' -import { mine } from '../../../actions/index.js' -import { signAuthorization } from '../../eip7702/actions/signAuthorization.js' +import { mine, signAuthorization } from '../../../actions/index.js' import { erc7821Actions } from './erc7821.js' const client = anvilMainnet @@ -33,6 +32,7 @@ describe('smoke test', () => { const authorization = await signAuthorization(client, { contractAddress: contractAddress!, + executor: 'self', }) await client.execute({ authorizationList: [authorization], @@ -56,6 +56,7 @@ describe('smoke test', () => { const authorization = await signAuthorization(client, { contractAddress: contractAddress!, + executor: 'self', }) await client.executeBatches({ authorizationList: [authorization], diff --git a/src/experimental/index.ts b/src/experimental/index.ts index abe5f61960..c18d6627ba 100644 --- a/src/experimental/index.ts +++ b/src/experimental/index.ts @@ -39,76 +39,16 @@ export { writeContracts, } from './eip5792/actions/writeContracts.js' export { - /** @deprecated use `Eip5792Actions` instead. */ - type Eip5792Actions as WalletActionsEip5792, - /** @deprecated use `eip5792Actions` instead. */ - eip5792Actions as walletActionsEip5792, type Eip5792Actions, eip5792Actions, } from './eip5792/decorators/eip5792.js' -export { - type Eip7702Actions, - eip7702Actions, -} from './eip7702/decorators/eip7702.js' -export { - type PrepareAuthorizationParameters, - type PrepareAuthorizationReturnType, - type PrepareAuthorizationErrorType, - prepareAuthorization, -} from './eip7702/actions/prepareAuthorization.js' -export { - type SignAuthorizationParameters, - type SignAuthorizationReturnType, - type SignAuthorizationErrorType, - signAuthorization, -} from './eip7702/actions/signAuthorization.js' -export { - type Authorization, - type SignedAuthorization, - type AuthorizationList, - type SignedAuthorizationList, - type SerializedAuthorization, - type SerializedAuthorizationList, -} from './eip7702/types/authorization.js' -export { - type RpcAuthorizationList, - type RpcAuthorization, -} from './eip7702/types/rpc.js' -export { - type HashAuthorizationParameters, - type HashAuthorizationReturnType, - type HashAuthorizationErrorType, - hashAuthorization, -} from './eip7702/utils/hashAuthorization.js' -export { - type RecoverAuthorizationAddressParameters, - type RecoverAuthorizationAddressReturnType, - type RecoverAuthorizationAddressErrorType, - recoverAuthorizationAddress, -} from './eip7702/utils/recoverAuthorizationAddress.js' -export { - type SerializeAuthorizationListReturnType, - type SerializeAuthorizationListErrorType, - serializeAuthorizationList, -} from './eip7702/utils/serializeAuthorizationList.js' -export { - type VerifyAuthorizationParameters, - type VerifyAuthorizationReturnType, - type VerifyAuthorizationErrorType, - verifyAuthorization, -} from './eip7702/utils/verifyAuthorization.js' - export { type GrantPermissionsParameters, type GrantPermissionsReturnType, grantPermissions, } from './erc7715/actions/grantPermissions.js' export { - /** @deprecated use `Erc7715Actions` instead. */ - type Erc7715Actions as WalletActionsErc7715, - /** @deprecated use `erc7715Actions` instead. */ - erc7715Actions as walletActionsErc7715, type Erc7715Actions, erc7715Actions, } from './erc7715/decorators/erc7715.js' @@ -123,34 +63,3 @@ export { type Erc7821Actions, erc7821Actions, } from './erc7821/decorators/erc7821.js' - -export { - /** @deprecated This is no longer experimental – use `import type { ParseErc6492SignatureErrorType } from 'viem'` instead. */ - type ParseErc6492SignatureErrorType, - /** @deprecated This is no longer experimental – use `import type { ParseErc6492SignatureParameters } from 'viem'` instead. */ - type ParseErc6492SignatureParameters, - /** @deprecated This is no longer experimental – use `import type { ParseErc6492SignatureReturnType } from 'viem'` instead. */ - type ParseErc6492SignatureReturnType, - /** @deprecated This is no longer experimental – use `import { parseErc6492Signature } from 'viem'` instead. */ - parseErc6492Signature, -} from '../utils/signature/parseErc6492Signature.js' -export { - /** @deprecated This is no longer experimental – use `import type { IsErc6492SignatureErrorType } from 'viem'` instead. */ - type IsErc6492SignatureErrorType, - /** @deprecated This is no longer experimental – use `import type { IsErc6492SignatureParameters } from 'viem'` instead. */ - type IsErc6492SignatureParameters, - /** @deprecated This is no longer experimental – use `import type { IsErc6492SignatureReturnType } from 'viem'` instead. */ - type IsErc6492SignatureReturnType, - /** @deprecated This is no longer experimental – use `import { isErc6492Signature } from 'viem'` instead. */ - isErc6492Signature, -} from '../utils/signature/isErc6492Signature.js' -export { - /** @deprecated This is no longer experimental – use `import type { SerializeErc6492SignatureErrorType } from 'viem'` instead. */ - type SerializeErc6492SignatureErrorType, - /** @deprecated This is no longer experimental – use `import type { SerializeErc6492SignatureParameters } from 'viem'` instead. */ - type SerializeErc6492SignatureParameters, - /** @deprecated This is no longer experimental – use `import type { SerializeErc6492SignatureReturnType } from 'viem'` instead. */ - type SerializeErc6492SignatureReturnType, - /** @deprecated This is no longer experimental – use `import { serializeErc6492Signature } from 'viem'` instead. */ - serializeErc6492Signature, -} from '../utils/signature/serializeErc6492Signature.js' diff --git a/src/index.ts b/src/index.ts index 13ef2c345b..c9aef1461c 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1127,9 +1127,19 @@ export type { DeriveAccount, HDKey, } from './types/account.js' +export type { + Authorization, + AuthorizationList, + SerializedAuthorization, + SerializedAuthorizationList, + SignedAuthorization, + SignedAuthorizationList, +} from './types/authorization.js' export type { Index, Quantity, + RpcAuthorization, + RpcAuthorizationList, RpcBlock, RpcBlockIdentifier, RpcBlockNumber, diff --git a/src/experimental/eip7702/types/authorization.ts b/src/types/authorization.ts similarity index 57% rename from src/experimental/eip7702/types/authorization.ts rename to src/types/authorization.ts index c858218d57..9db4cd5ec2 100644 --- a/src/experimental/eip7702/types/authorization.ts +++ b/src/types/authorization.ts @@ -1,21 +1,36 @@ import type { Address } from 'abitype' -import type { Hex, Signature } from '../../../types/misc.js' -import type { ExactPartial } from '../../../types/utils.js' +import type { Hex, Signature } from './misc.js' +import type { ExactPartial, OneOf } from './utils.js' -export type Authorization = { - /** Address of the contract to set as code for the Authority. */ - contractAddress: Address - /** Chain ID to authorize. */ +export type Authorization< + uint32 = number, + signed extends boolean = false, +> = OneOf< + | { + /** + * Address of the contract to delegate to. + * @alias `address` + */ + contractAddress: Address + } + | { + /** Address of the contract to delegate to. */ + address: Address + } +> & { + /** Chain ID. */ chainId: uint32 - /** Nonce of the Authority to authorize. */ + /** Nonce of the EOA to delegate to. */ nonce: uint32 } & (signed extends true ? Signature : ExactPartial) + export type AuthorizationList< uint32 = number, signed extends boolean = false, > = readonly Authorization[] export type SignedAuthorization = Authorization + export type SignedAuthorizationList = readonly SignedAuthorization[] diff --git a/src/types/rpc.ts b/src/types/rpc.ts index 246078ca9d..2bcab2cc54 100644 --- a/src/types/rpc.ts +++ b/src/types/rpc.ts @@ -1,6 +1,5 @@ import type { Address } from 'abitype' -import type { RpcAuthorizationList } from '../experimental/eip7702/types/rpc.js' import type { Block, BlockIdentifier, @@ -38,6 +37,21 @@ export type TransactionType = | '0x4' | (string & {}) +export type RpcAuthorization = { + /** Address of the contract to set as code for the Authority. */ + address: Address + /** Chain ID to authorize. */ + chainId: Hex + /** Nonce of the Authority to authorize. */ + nonce: Hex + /** ECDSA r value. */ + r: Hex + /** ECDSA s value. */ + s: Hex + /** y parity. */ + yParity: Hex +} +export type RpcAuthorizationList = readonly RpcAuthorization[] export type RpcBlock< blockTag extends BlockTag = BlockTag, includeTransactions extends boolean = boolean, diff --git a/src/types/transaction.ts b/src/types/transaction.ts index 7880e25472..310d27d82b 100644 --- a/src/types/transaction.ts +++ b/src/types/transaction.ts @@ -3,7 +3,7 @@ import type { Address } from 'abitype' import type { AuthorizationList, SignedAuthorizationList, -} from '../experimental/eip7702/types/authorization.js' +} from './authorization.js' import type { BlobSidecar } from './eip4844.js' import type { FeeValuesEIP1559, diff --git a/src/experimental/eip7702/utils/hashAuthorization.test.ts b/src/utils/authorization/hashAuthorization.test.ts similarity index 85% rename from src/experimental/eip7702/utils/hashAuthorization.test.ts rename to src/utils/authorization/hashAuthorization.test.ts index f4118f7fbc..482f9d812e 100644 --- a/src/experimental/eip7702/utils/hashAuthorization.test.ts +++ b/src/utils/authorization/hashAuthorization.test.ts @@ -1,5 +1,5 @@ import { expect, test } from 'vitest' -import { wagmiContractConfig } from '../../../../test/src/abis.js' +import { wagmiContractConfig } from '../../../test/src/abis.js' import { hashAuthorization } from './hashAuthorization.js' test('default', () => { @@ -34,6 +34,18 @@ test('default', () => { ) }) +test('args: address (alias)', () => { + expect( + hashAuthorization({ + address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c', + chainId: 1, + nonce: 40, + }), + ).toMatchInlineSnapshot( + `"0x5919da563810a99caf657d42bd10905adbd28b3b89b8a4577efa471e5e4b3914"`, + ) +}) + test('args: to', () => { expect( hashAuthorization({ diff --git a/src/experimental/eip7702/utils/hashAuthorization.ts b/src/utils/authorization/hashAuthorization.ts similarity index 61% rename from src/experimental/eip7702/utils/hashAuthorization.ts rename to src/utils/authorization/hashAuthorization.ts index def8a6e2f2..5eae49dc30 100644 --- a/src/experimental/eip7702/utils/hashAuthorization.ts +++ b/src/utils/authorization/hashAuthorization.ts @@ -1,23 +1,11 @@ -import type { ErrorType } from '../../../errors/utils.js' -import type { ByteArray, Hex } from '../../../types/misc.js' -import { - type ConcatHexErrorType, - concatHex, -} from '../../../utils/data/concat.js' -import { - type HexToBytesErrorType, - hexToBytes, -} from '../../../utils/encoding/toBytes.js' -import { - type NumberToHexErrorType, - numberToHex, -} from '../../../utils/encoding/toHex.js' -import { type ToRlpErrorType, toRlp } from '../../../utils/encoding/toRlp.js' -import { - type Keccak256ErrorType, - keccak256, -} from '../../../utils/hash/keccak256.js' -import type { Authorization } from '../types/authorization.js' +import type { ErrorType } from '../../errors/utils.js' +import type { Authorization } from '../../types/authorization.js' +import type { ByteArray, Hex } from '../../types/misc.js' +import { type ConcatHexErrorType, concatHex } from '../data/concat.js' +import { type HexToBytesErrorType, hexToBytes } from '../encoding/toBytes.js' +import { type NumberToHexErrorType, numberToHex } from '../encoding/toHex.js' +import { type ToRlpErrorType, toRlp } from '../encoding/toRlp.js' +import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js' type To = 'hex' | 'bytes' @@ -44,7 +32,8 @@ export type HashAuthorizationErrorType = export function hashAuthorization( parameters: HashAuthorizationParameters, ): HashAuthorizationReturnType { - const { chainId, contractAddress, nonce, to } = parameters + const { chainId, nonce, to } = parameters + const contractAddress = parameters.contractAddress ?? parameters.address const hash = keccak256( concatHex([ '0x05', diff --git a/src/experimental/eip7702/utils/recoverAuthorizationAddress.test.ts b/src/utils/authorization/recoverAuthorizationAddress.test.ts similarity index 74% rename from src/experimental/eip7702/utils/recoverAuthorizationAddress.test.ts rename to src/utils/authorization/recoverAuthorizationAddress.test.ts index 5f7f5f4306..23b3ed368f 100644 --- a/src/experimental/eip7702/utils/recoverAuthorizationAddress.test.ts +++ b/src/utils/authorization/recoverAuthorizationAddress.test.ts @@ -2,13 +2,13 @@ import { expect, test } from 'vitest' import { accounts } from '~test/src/constants.js' -import { wagmiContractConfig } from '../../../../test/src/abis.js' -import { experimental_signAuthorization } from '../../../accounts/utils/signAuthorization.js' -import { getAddress } from '../../../utils/address/getAddress.js' +import { wagmiContractConfig } from '../../../test/src/abis.js' +import { signAuthorization } from '../../accounts/utils/signAuthorization.js' +import { getAddress } from '../address/getAddress.js' import { recoverAuthorizationAddress } from './recoverAuthorizationAddress.js' test('default', async () => { - const signedAuthorization = await experimental_signAuthorization({ + const signedAuthorization = await signAuthorization({ contractAddress: wagmiContractConfig.address, chainId: 1, nonce: 0, @@ -27,7 +27,7 @@ test('args: signature', async () => { chainId: 1, nonce: 0, } as const - const signature = await experimental_signAuthorization({ + const signature = await signAuthorization({ ...authorization, privateKey: accounts[0].privateKey, }) @@ -45,7 +45,7 @@ test('args: signature (hex)', async () => { chainId: 1, nonce: 0, } as const - const signature = await experimental_signAuthorization({ + const signature = await signAuthorization({ ...authorization, privateKey: accounts[0].privateKey, to: 'hex', diff --git a/src/experimental/eip7702/utils/recoverAuthorizationAddress.ts b/src/utils/authorization/recoverAuthorizationAddress.ts similarity index 86% rename from src/experimental/eip7702/utils/recoverAuthorizationAddress.ts rename to src/utils/authorization/recoverAuthorizationAddress.ts index c236923354..148cf431ef 100644 --- a/src/experimental/eip7702/utils/recoverAuthorizationAddress.ts +++ b/src/utils/authorization/recoverAuthorizationAddress.ts @@ -1,16 +1,16 @@ import type { Address } from 'abitype' -import type { ErrorType } from '../../../errors/utils.js' -import type { ByteArray, Hex, Signature } from '../../../types/misc.js' -import type { OneOf } from '../../../types/utils.js' -import { - type RecoverAddressErrorType, - recoverAddress, -} from '../../../utils/signature/recoverAddress.js' +import type { ErrorType } from '../../errors/utils.js' import type { Authorization, SignedAuthorization, -} from '../types/authorization.js' +} from '../../types/authorization.js' +import type { ByteArray, Hex, Signature } from '../../types/misc.js' +import type { OneOf } from '../../types/utils.js' +import { + type RecoverAddressErrorType, + recoverAddress, +} from '../signature/recoverAddress.js' import { type HashAuthorizationErrorType, hashAuthorization, diff --git a/src/experimental/eip7702/utils/serializeAuthorizationList.test.ts b/src/utils/authorization/serializeAuthorizationList.test.ts similarity index 78% rename from src/experimental/eip7702/utils/serializeAuthorizationList.test.ts rename to src/utils/authorization/serializeAuthorizationList.test.ts index de1b337083..8722e4dacf 100644 --- a/src/experimental/eip7702/utils/serializeAuthorizationList.test.ts +++ b/src/utils/authorization/serializeAuthorizationList.test.ts @@ -1,5 +1,5 @@ import { expect, test } from 'vitest' -import { wagmiContractConfig } from '../../../../test/src/abis.js' +import { wagmiContractConfig } from '../../../test/src/abis.js' import { serializeAuthorizationList } from './serializeAuthorizationList.js' test('default', () => { @@ -30,6 +30,30 @@ test('default', () => { ] `) + expect( + serializeAuthorizationList([ + { + address: wagmiContractConfig.address, + chainId: 1, + nonce: 69, + r: '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe', + s: '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe', + yParity: 1, + }, + ]), + ).toMatchInlineSnapshot(` + [ + [ + "0x1", + "0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2", + "0x45", + "0x1", + "0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe", + "0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe", + ], + ] + `) + expect( serializeAuthorizationList([ { diff --git a/src/experimental/eip7702/utils/serializeAuthorizationList.ts b/src/utils/authorization/serializeAuthorizationList.ts similarity index 70% rename from src/experimental/eip7702/utils/serializeAuthorizationList.ts rename to src/utils/authorization/serializeAuthorizationList.ts index 3f8f4e66d9..9728af50b7 100644 --- a/src/experimental/eip7702/utils/serializeAuthorizationList.ts +++ b/src/utils/authorization/serializeAuthorizationList.ts @@ -1,10 +1,10 @@ -import type { ErrorType } from '../../../errors/utils.js' -import { toHex } from '../../../utils/encoding/toHex.js' -import { toYParitySignatureArray } from '../../../utils/transaction/serializeTransaction.js' +import type { ErrorType } from '../../errors/utils.js' import type { AuthorizationList, SerializedAuthorizationList, -} from '../types/authorization.js' +} from '../../types/authorization.js' +import { toHex } from '../encoding/toHex.js' +import { toYParitySignatureArray } from '../transaction/serializeTransaction.js' export type SerializeAuthorizationListReturnType = SerializedAuthorizationList @@ -20,7 +20,9 @@ export function serializeAuthorizationList( const serializedAuthorizationList = [] for (const authorization of authorizationList) { - const { contractAddress, chainId, nonce, ...signature } = authorization + const { chainId, nonce, ...signature } = authorization + const contractAddress = + authorization.contractAddress ?? authorization.address serializedAuthorizationList.push([ chainId ? toHex(chainId) : '0x', contractAddress, diff --git a/src/experimental/eip7702/utils/verifyAuthorization.test.ts b/src/utils/authorization/verifyAuthorization.test.ts similarity index 58% rename from src/experimental/eip7702/utils/verifyAuthorization.test.ts rename to src/utils/authorization/verifyAuthorization.test.ts index ef9f334546..1c124524e8 100644 --- a/src/experimental/eip7702/utils/verifyAuthorization.test.ts +++ b/src/utils/authorization/verifyAuthorization.test.ts @@ -2,12 +2,12 @@ import { expect, test } from 'vitest' import { accounts } from '~test/src/constants.js' -import { wagmiContractConfig } from '../../../../test/src/abis.js' -import { experimental_signAuthorization } from '../../../accounts/utils/signAuthorization.js' +import { wagmiContractConfig } from '../../../test/src/abis.js' +import { signAuthorization } from '../../accounts/utils/signAuthorization.js' import { verifyAuthorization } from './verifyAuthorization.js' test('default', async () => { - const authorization = await experimental_signAuthorization({ + const authorization = await signAuthorization({ contractAddress: wagmiContractConfig.address, chainId: 1, nonce: 0, @@ -21,13 +21,28 @@ test('default', async () => { ).toBe(true) }) +test('args: address (alias)', async () => { + const authorization = await signAuthorization({ + address: wagmiContractConfig.address, + chainId: 1, + nonce: 0, + privateKey: accounts[0].privateKey, + }) + expect( + await verifyAuthorization({ + address: accounts[0].address, + authorization, + }), + ).toBe(true) +}) + test('args: signature', async () => { const authorization = { contractAddress: wagmiContractConfig.address, chainId: 1, nonce: 0, } as const - const signature = await experimental_signAuthorization({ + const signature = await signAuthorization({ ...authorization, privateKey: accounts[0].privateKey, }) diff --git a/src/experimental/eip7702/utils/verifyAuthorization.ts b/src/utils/authorization/verifyAuthorization.ts similarity index 86% rename from src/experimental/eip7702/utils/verifyAuthorization.ts rename to src/utils/authorization/verifyAuthorization.ts index 176250fd56..82aa585557 100644 --- a/src/experimental/eip7702/utils/verifyAuthorization.ts +++ b/src/utils/authorization/verifyAuthorization.ts @@ -1,14 +1,11 @@ import type { Address } from 'abitype' -import type { ErrorType } from '../../../errors/utils.js' -import { - type GetAddressErrorType, - getAddress, -} from '../../../utils/address/getAddress.js' +import type { ErrorType } from '../../errors/utils.js' +import { type GetAddressErrorType, getAddress } from '../address/getAddress.js' import { type IsAddressEqualErrorType, isAddressEqual, -} from '../../../utils/address/isAddressEqual.js' +} from '../address/isAddressEqual.js' import { type RecoverAuthorizationAddressErrorType, type RecoverAuthorizationAddressParameters, diff --git a/src/utils/formatters/transaction.ts b/src/utils/formatters/transaction.ts index 34974c04ea..2ec0088bd5 100644 --- a/src/utils/formatters/transaction.ts +++ b/src/utils/formatters/transaction.ts @@ -1,6 +1,5 @@ import type { ErrorType } from '../../errors/utils.js' -import type { SignedAuthorizationList } from '../../experimental/eip7702/types/authorization.js' -import type { RpcAuthorizationList } from '../../experimental/eip7702/types/rpc.js' +import type { SignedAuthorizationList } from '../../types/authorization.js' import type { BlockTag } from '../../types/block.js' import type { Chain } from '../../types/chain.js' import type { @@ -8,7 +7,7 @@ import type { ExtractChainFormatterReturnType, } from '../../types/chain.js' import type { Hex } from '../../types/misc.js' -import type { RpcTransaction } from '../../types/rpc.js' +import type { RpcAuthorizationList, RpcTransaction } from '../../types/rpc.js' import type { Transaction, TransactionType } from '../../types/transaction.js' import type { ExactPartial, UnionLooseOmit } from '../../types/utils.js' import { hexToNumber } from '../encoding/fromHex.js' diff --git a/src/utils/formatters/transactionRequest.ts b/src/utils/formatters/transactionRequest.ts index 0feb9cb514..67882b59e5 100644 --- a/src/utils/formatters/transactionRequest.ts +++ b/src/utils/formatters/transactionRequest.ts @@ -1,12 +1,14 @@ import type { ErrorType } from '../../errors/utils.js' -import type { AuthorizationList } from '../../experimental/eip7702/types/authorization.js' -import type { RpcAuthorizationList } from '../../experimental/eip7702/types/rpc.js' +import type { AuthorizationList } from '../../types/authorization.js' import type { Chain, ExtractChainFormatterParameters, } from '../../types/chain.js' import type { ByteArray } from '../../types/misc.js' -import type { RpcTransactionRequest } from '../../types/rpc.js' +import type { + RpcAuthorizationList, + RpcTransactionRequest, +} from '../../types/rpc.js' import type { TransactionRequest } from '../../types/transaction.js' import type { ExactPartial } from '../../types/utils.js' import { bytesToHex, numberToHex } from '../encoding/toHex.js' diff --git a/src/utils/index.test.ts b/src/utils/index.test.ts index a212b520f6..387b72faf1 100644 --- a/src/utils/index.test.ts +++ b/src/utils/index.test.ts @@ -48,6 +48,10 @@ test('exports utils', () => { "formatAbiItemWithArgs", "formatAbiItem", "formatAbiParams", + "hashAuthorization", + "recoverAuthorizationAddress", + "serializeAuthorizationList", + "verifyAuthorization", "parseAccount", "publicKeyToAddress", "getContractAddress", diff --git a/src/utils/index.ts b/src/utils/index.ts index 64ac710f1d..0bd273c2ac 100644 --- a/src/utils/index.ts +++ b/src/utils/index.ts @@ -162,6 +162,29 @@ export { formatAbiItem, formatAbiParams, } from './abi/formatAbiItem.js' +export { + type HashAuthorizationErrorType, + type HashAuthorizationParameters, + type HashAuthorizationReturnType, + hashAuthorization, +} from './authorization/hashAuthorization.js' +export { + type RecoverAuthorizationAddressErrorType, + type RecoverAuthorizationAddressParameters, + type RecoverAuthorizationAddressReturnType, + recoverAuthorizationAddress, +} from './authorization/recoverAuthorizationAddress.js' +export { + type SerializeAuthorizationListErrorType, + type SerializeAuthorizationListReturnType, + serializeAuthorizationList, +} from './authorization/serializeAuthorizationList.js' +export { + type VerifyAuthorizationErrorType, + type VerifyAuthorizationParameters, + type VerifyAuthorizationReturnType, + verifyAuthorization, +} from './authorization/verifyAuthorization.js' export { type ParseAccountErrorType, parseAccount, diff --git a/src/utils/transaction/assertTransaction.ts b/src/utils/transaction/assertTransaction.ts index 0354fa39ee..c377bf2cbb 100644 --- a/src/utils/transaction/assertTransaction.ts +++ b/src/utils/transaction/assertTransaction.ts @@ -48,9 +48,9 @@ export function assertTransactionEIP7702( const { authorizationList } = transaction if (authorizationList) { for (const authorization of authorizationList) { - const { contractAddress, chainId } = authorization - if (!isAddress(contractAddress)) - throw new InvalidAddressError({ address: contractAddress }) + const { chainId } = authorization + const address = authorization.contractAddress ?? authorization.address + if (!isAddress(address)) throw new InvalidAddressError({ address }) if (chainId < 0) throw new InvalidChainIdError({ chainId }) } } diff --git a/src/utils/transaction/parseTransaction.ts b/src/utils/transaction/parseTransaction.ts index 6a7600f25d..93a3edcffa 100644 --- a/src/utils/transaction/parseTransaction.ts +++ b/src/utils/transaction/parseTransaction.ts @@ -12,7 +12,7 @@ import type { ErrorType } from '../../errors/utils.js' import type { SerializedAuthorizationList, SignedAuthorizationList, -} from '../../experimental/eip7702/types/authorization.js' +} from '../../types/authorization.js' import type { Hex, Signature } from '../../types/misc.js' import type { AccessList, diff --git a/src/utils/transaction/serializeTransaction.ts b/src/utils/transaction/serializeTransaction.ts index a8aa0baf07..cd772c5c01 100644 --- a/src/utils/transaction/serializeTransaction.ts +++ b/src/utils/transaction/serializeTransaction.ts @@ -26,6 +26,10 @@ import type { TransactionType, } from '../../types/transaction.js' import type { OneOf } from '../../types/utils.js' +import { + type SerializeAuthorizationListErrorType, + serializeAuthorizationList, +} from '../authorization/serializeAuthorizationList.js' import { type BlobsToCommitmentsErrorType, blobsToCommitments, @@ -47,10 +51,6 @@ import { trim } from '../data/trim.js' import { type ToHexErrorType, bytesToHex, toHex } from '../encoding/toHex.js' import { type ToRlpErrorType, toRlp } from '../encoding/toRlp.js' -import { - type SerializeAuthorizationListErrorType, - serializeAuthorizationList, -} from '../../experimental/eip7702/utils/serializeAuthorizationList.js' import { type AssertTransactionEIP1559ErrorType, type AssertTransactionEIP2930ErrorType, diff --git a/src/zksync/accounts/toMultisigSmartAccount.test.ts b/src/zksync/accounts/toMultisigSmartAccount.test.ts index 7970ed58df..ffc7e3cae6 100644 --- a/src/zksync/accounts/toMultisigSmartAccount.test.ts +++ b/src/zksync/accounts/toMultisigSmartAccount.test.ts @@ -14,9 +14,9 @@ test('default', () => { ).toMatchInlineSnapshot(` { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": undefined, "nonceManager": undefined, "sign": [Function], + "signAuthorization": undefined, "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], diff --git a/src/zksync/accounts/toSinglesigSmartAccount.test.ts b/src/zksync/accounts/toSinglesigSmartAccount.test.ts index d04a41d03c..5e1883ea34 100644 --- a/src/zksync/accounts/toSinglesigSmartAccount.test.ts +++ b/src/zksync/accounts/toSinglesigSmartAccount.test.ts @@ -14,9 +14,9 @@ test('default', () => { ).toMatchInlineSnapshot(` { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": undefined, "nonceManager": undefined, "sign": [Function], + "signAuthorization": undefined, "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function], diff --git a/src/zksync/accounts/toSmartAccount.test.ts b/src/zksync/accounts/toSmartAccount.test.ts index 9abd1b5bd3..c6d607a460 100644 --- a/src/zksync/accounts/toSmartAccount.test.ts +++ b/src/zksync/accounts/toSmartAccount.test.ts @@ -25,9 +25,9 @@ test('default', () => { ).toMatchInlineSnapshot(` { "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", - "experimental_signAuthorization": undefined, "nonceManager": undefined, "sign": [Function], + "signAuthorization": undefined, "signMessage": [Function], "signTransaction": [Function], "signTypedData": [Function],