Merge branch 'main' into restructure-ew

Author: yashovardhan

delegation-toolkit/concepts/erc7715.md

@@ -13,7 +13,7 @@ ERC-7715 eliminates the need for users to approve every transaction, which is us
 It also enables dapps to execute transactions for users without an active wallet connection.
 
 :::note
-This feature requires [MetaMask Flask 12.14.2](/snaps/get-started/install-flask) or later.
+This feature requires [MetaMask Flask 13.5.0](/snaps/get-started/install-flask) or later.
 :::
 
 ## ERC-7715 technical overview

delegation-toolkit/experimental/erc-7715-request-permissions.md

@@ -9,7 +9,7 @@ import TabItem from "@theme/TabItem";
 
 :::caution Experimental
 This is an experimental feature.
-It requires MetaMask Flask 12.14.2 or later, and may change in future releases.
+It requires MetaMask Flask 13.5.0 or later, and may change in future releases.
 :::
 
 [ERC-7715](https://eip.tools/eip/7715) introduces a standard way for dapps to request permissions from a wallet to execute

delegation-toolkit/guides/delegation/check-delegation-state.md

@@ -82,14 +82,18 @@ const { availableAmount } = await caveatEnforcerClient.getErc20PeriodTransferEnf
 
 ```typescript
 import { createDelegation } from '@metamask/delegation-toolkit'
+import { parseUnits } from 'viem'
+
+// startDate should be in seconds.
+const startDate = Math.floor(Date.now() / 1000);
 
 export const delegation = createDelegation({
   scope: {
     type: 'erc20PeriodTransfer',
     tokenAddress: '0xb4aE654Aca577781Ca1c5DE8FbE60c2F423f37da',
-    periodAmount: 1000000000000000000n,
+    periodAmount: parseUnits('10', 6),
     periodDuration: 86400,
-    startDate: 1743763600,
+    startDate,
   },
   to: delegateAccount,
   from: delegatorAccount,

delegation-toolkit/guides/delegation/disable-delegation.md

@@ -0,0 +1,99 @@
+---
+description: Learn how to disable the delegation.
+sidebar_label: Disable a delegation
+toc_max_heading_level: 3
+keywords: [delegation, disable, revoke]
+---
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+# Disable a delegation
+
+Delegations are created off-chain and can be stored anywhere, but you can disable a delegation on-chain using the
+toolkit. When a delegation is disabled, any attempt to redeem it will revert, effectively revoking the permissions 
+that were previously granted.
+
+For example, if Alice has given permission to Bob to spend 10 USDC on her behalf, and after a week she wants to 
+revoke that permission, Alice can disable the delegation she created for Bob. If Bob tries to redeem the disabled 
+delegation, the transaction will revert, preventing him from spending Alice's USDC.
+
+## Prerequisites
+
+- [Install and set up the Delegation Toolkit.](../../get-started/install.md)
+- [Create a delegator account.](execute-on-smart-accounts-behalf.md#3-create-a-delegator-account)
+- [Create a delegate account.](execute-on-smart-accounts-behalf.md#4-create-a-delegate-account)
+
+
+## Disable a delegation
+
+To disable a delegation, you can use the [`disableDelegation`](../../reference/delegation/index.md#disabledelegation) utility function from the 
+toolkit to generate calldata. Once the calldata is prepared, you can send it to the
+Delegation Manager to disable the delegation. 
+
+<Tabs>
+<TabItem value="example.ts">
+
+```typescript
+import { DelegationManager } from '@metamask/delegation-toolkit/contracts';
+import { environment, delegation, bundlerClient } from "./config.ts";
+
+const disableDelegationData = DelegationManager.encode.disableDelegation({
+  delegation,
+});
+
+// Appropriate fee per gas must be determined for the specific bundler being used.
+const maxFeePerGas = 1n;
+const maxPriorityFeePerGas = 1n;
+
+const userOperationHash = await bundlerClient.sendUserOperation({
+  account: delegatorAccount,
+  calls: [
+    {
+      to: environment.DelegationManager,
+      data: disableDelegationData
+    }
+  ],
+  maxFeePerGas,
+  maxPriorityFeePerGas
+});
+```
+
+</TabItem>
+<TabItem value="config.ts">
+
+```typescript
+import { sepolia as chain } from 'viem/chains'
+import { createPublicClient, http, parseEther } from 'viem'
+import { createBundlerClient } from 'viem/account-abstraction'
+import { getDeleGatorEnvironment, createDelegation } from '@metamask/delegation-toolkit'
+
+export const environment = getDeleGatorEnvironment(chain.id)
+
+const currentTime = Math.floor(Date.now() / 1000)
+
+export const delegation = createDelegation({
+  scope: {
+    type: 'nativeTokenPeriodTransfer',
+    periodAmount: parseEther('0.01'),
+    periodDuration: 86400,
+    startDate: currentTime,
+  },
+  to: delegateAccount,
+  from: delegatorAccount,
+  environment: delegatorAccount.environment,
+})
+
+const publicClient = createPublicClient({
+  chain,
+  transport: http()
+})
+
+export const bundlerClient = createBundlerClient({
+  client: publicClient,
+  transport: http('https://api.pimlico.io/v2/11155111/rpc')
+});
+```
+
+</TabItem>
+</Tabs>

delegation-toolkit/guides/delegation/execute-on-smart-accounts-behalf.md

@@ -137,9 +137,10 @@ Before creating a delegation, ensure that the delegator account (in this example
 
 ```typescript
 import { createDelegation } from "@metamask/delegation-toolkit"
+import { parseUnits } from "viem"
 
 // USDC address on Ethereum Sepolia.
-const tokenAddress = "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238";
+const tokenAddress = "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
 
 const delegation = createDelegation({
   to: delegateSmartAccount.address, // This example uses a delegate smart account
@@ -148,7 +149,8 @@ const delegation = createDelegation({
   scope: {
     type: "erc20TransferAmount",
     tokenAddress,
-    maxAmount: 10000000n,
+    // 10 USDC 
+    maxAmount: parseUnits("10", 6),
   },
 })
 ```
@@ -175,7 +177,7 @@ Bob can now redeem the delegation. The redeem transaction is sent to the `Delega
 To prepare the calldata for the redeem transaction, use the [`redeemDelegations`](../../reference/delegation/index.md#redeemdelegations) method from `DelegationManager`.
 Since Bob is redeeming a single delegation chain, use the [`SingleDefault`](../../concepts/delegation/index.md#execution-modes) execution mode.
 
-Bob can redeem the delegation by submitting a user operation if his account is a smart account, or a regular transaction if his account is an EOA:
+Bob can redeem the delegation by submitting a user operation if his account is a smart account, or a regular transaction if his account is an EOA. In this example, Bob transfers 1 USDC from Alice’s account to his own.
 
 <Tabs>
 <TabItem value="Redeem with a smart account">
@@ -184,10 +186,14 @@ Bob can redeem the delegation by submitting a user operation if his account is a
 import { createExecution, ExecutionMode } from "@metamask/delegation-toolkit"
 import { DelegationManager } from "@metamask/delegation-toolkit/contracts"
 import { zeroAddress } from "viem"
+import { callData } from "./config.ts"
 
 const delegations = [signedDelegation]
 
-const executions = createExecution({ target: zeroAddress })
+// USDC address on Ethereum Sepolia.
+const tokenAddress = "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
+
+const executions = createExecution({ target: tokenAddress, callData })
 
 const redeemDelegationCalldata = DelegationManager.encode.redeemDelegations({
   delegations: [delegations],
@@ -215,10 +221,14 @@ const userOperationHash = await bundlerClient.sendUserOperation({
 import { createExecution, getDeleGatorEnvironment, ExecutionMode } from "@metamask/delegation-toolkit"
 import { DelegationManager } from "@metamask/delegation-toolkit/contracts"
 import { zeroAddress } from "viem"
+import { callData } from "./config.ts"
 
 const delegations = [signedDelegation]
 
-const executions = createExecution({ target: zeroAddress })
+// USDC address on Ethereum Sepolia.
+const tokenAddress = "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
+
+const executions = createExecution({ target: tokenAddress, callData })
 
 const redeemDelegationCalldata = DelegationManager.encode.redeemDelegations({
   delegations: [delegations],
@@ -233,10 +243,26 @@ const transactionHash = await delegateWalletClient.sendTransaction({
 })
 ```
 
+</TabItem>
+
+<TabItem value="config.ts">
+
+```typescript
+import { encodeFunctionData, erc20Abi, parseUnits } from "viem"
+
+// calldata to transfer 1 USDC to delegate address.
+export const callData = encodeFunctionData({
+  abi: erc20Abi,
+  args: [ delegateSmartAccount.address, parseUnits("1", 6) ],
+  functionName: 'transfer',
+})
+```
+
 </TabItem>
 </Tabs>
 
 ## Next steps
 
 - See [how to configure different scopes](use-delegation-scopes/index.md) to define the initial authority of a delegation.
-- See [how to further refine the authority of a delegation](use-delegation-scopes/constrain-scope.md) using caveat enforcers.
+- See [how to further refine the authority of a delegation](use-delegation-scopes/constrain-scope.md) using caveat enforcers.
+- See [how to disable a delegation](disable-delegation.md) to revoke permissions.

delegation-toolkit/guides/delegation/use-delegation-scopes/function-call.md

@@ -3,14 +3,14 @@ description: Learn how to use the function call scope for a delegation.
 keywords: [delegation scope, function call, restrict, delegation]
 ---
 
+import Tabs from "@theme/Tabs"; 
+import TabItem from "@theme/TabItem";
+
 # Use the function call scope
 
 The function call scope defines the specific methods, contract addresses, and calldata that are allowed for the delegation.
 For example, Alice delegates to Bob the ability to call the `approve` function on the USDC contract, with the approval amount set to `0`.
 
-Internally, this scope uses the [`allowedTargets`](../../../reference/delegation/caveats.md#allowedtargets) and [`allowedMethods`](../../../reference/delegation/caveats.md#allowedmethods) caveat enforcers, and 
-optionally uses the [`allowedCalldata`](../../../reference/delegation/caveats.md#allowedcalldata) or [`exactCalldata`](../../../reference/delegation/caveats.md#exactcalldata) caveat enforcers when those parameters are specified.
-
 ## Prerequisites
 
 - [Install and set up the Delegation Toolkit.](../../../get-started/install.md)
@@ -20,10 +20,13 @@ optionally uses the [`allowedCalldata`](../../../reference/delegation/caveats.md
 
 ## Function call scope
 
-This scope requires `targets` and `selectors` as mandatory parameters for the configuration.
-You can specify the allowed methods in `selectors` and the permitted contract addresses in `targets`. 
+This scope requires `targets`, which specifies the permitted contract addresses, and `selectors`, which specifies the allowed methods.
+
+Internally, this scope uses the [`allowedTargets`](../../../reference/delegation/caveats.md#allowedtargets) and [`allowedMethods`](../../../reference/delegation/caveats.md#allowedmethods) caveat enforcers, and 
+optionally uses the [`allowedCalldata`](../../../reference/delegation/caveats.md#allowedcalldata) or [`exactCalldata`](../../../reference/delegation/caveats.md#exactcalldata) caveat enforcers when those parameters are specified.
+See the [function call scope reference](../../../reference/delegation/delegation-scopes.md#function-call-scope) for more details.
 
-The following example sets the delegation scope to allow the delegate to call the `approve` function on the USDC token contract.
+The following example sets the delegation scope to allow the delegate to call the `approve` function on the USDC token contract:
 
 ```typescript
 import { createDelegation } from "@metamask/delegation-toolkit";
@@ -35,7 +38,85 @@ const delegation = createDelegation({
   scope: {
     type: "functionCall",
     targets: [USDC_ADDRESS],
-    selectors: ["approve(address, uint256)"]
+    selectors: ["approve(address, uint256)"],
+  },
+  to: delegateAccount,
+  from: delegatorAccount,
+  environment: delegatorAccount.environment,
+});
+```
+
+### Define allowed calldata
+
+You can further restrict the scope by defining the `allowedCalldata`. For example, you can set 
+`allowedCalldata` so the delegate is only permitted to call the `approve` function on the
+USDC token contract with an allowance value of `0`. This effectively limits the delegate to 
+revoking ERC-20 approvals.
+
+:::important Usage
+The `allowedCalldata` doesn't support multiple selectors. Each entry in the
+list represents a portion of calldata corresponding to the same function signature.
+
+You can include or exclude specific parameters to precisely define what parts of the calldata are valid.
+:::
+
+```typescript
+import { createDelegation } from "@metamask/delegation-toolkit";
+import { encodeAbiParameters, erc20Abi } from "viem";
+
+// USDC address on Sepolia.
+const USDC_ADDRESS = "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238";
+
+const delegation = createDelegation({
+  scope: {
+    type: "functionCall",
+    targets: [USDC_ADDRESS],
+    selectors: ["approve(address, uint256)"],
+    allowedCalldata: [
+      {
+        // Limits the allowance amount to be 0.
+        value: encodeAbiParameters(
+          [{ name: 'amount', type: 'uint256' }],
+          [0n],
+        ),
+        // The first 4 bytes are for selector, and next 32 bytes 
+        // are for spender address.
+        startIndex: 36,
+      },
+    ]
+  },
+  to: delegateAccount,
+  from: delegatorAccount,
+  environment: delegatorAccount.environment,
+});
+```
+
+### Define exact calldata
+
+You can define the `exactCalldata` instead of the `allowedCalldata`. For example, you can
+set `exactCalldata` so the delegate is permitted to call only the `approve` function on the USDC token
+contract, with a specific spender address and an allowance value of 0. This effectively limits the delegate to
+revoking ERC-20 approvals for a specific spender.
+
+```typescript
+import { createDelegation } from "@metamask/delegation-toolkit";
+import { encodeFunctionData, erc20Abi } from "viem";
+
+// USDC address on Sepolia.
+const USDC_ADDRESS = "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238";
+
+const delegation = createDelegation({
+  scope: {
+    type: "functionCall",
+    targets: [USDC_ADDRESS],
+    selectors: ["approve(address, uint256)"],
+    exactCalldata: {
+      calldata: encodeFunctionData({
+        abi: erc20Abi,
+        args: ["0x0227628f3F023bb0B980b67D528571c95c6DaC1c", 0n],
+        functionName: 'approve',
+      })
+    }
   },
   to: delegateAccount,
   from: delegatorAccount,

delegation-toolkit/guides/delegation/use-delegation-scopes/ownership-transfer.md

@@ -8,8 +8,6 @@ keywords: [delegation scope, ownership transfer, restrict, delegation]
 The ownership transfer scope restricts a delegation to ownership transfer calls only.
 For example, Alice has deployed a smart contract, and she delegates to Bob the ability to transfer ownership of that contract.
 
-Internally, this scope uses the [`ownershipTransfer`](../../../reference/delegation/caveats.md#ownershiptransfer) caveat enforcer.
-
 ## Prerequisites
 
 - [Install and set up the Delegation Toolkit.](../../../get-started/install.md)
@@ -21,6 +19,9 @@ Internally, this scope uses the [`ownershipTransfer`](../../../reference/delegat
 
 This scope requires a `contractAddress`, which represents the address of the deployed contract.
 
+Internally, this scope uses the [`ownershipTransfer`](../../../reference/delegation/caveats.md#ownershiptransfer) caveat enforcer.
+See the [ownership transfer scope reference](../../../reference/delegation/delegation-scopes.md#ownership-transfer-scope) for more details.
+
 ```typescript
 import { createDelegation } from "@metamask/delegation-toolkit";