If parent delegation is an opendelegation, from should be the signer

Author: jeffsmale90

packages/smart-accounts-kit/src/actions/redelegatePermissionContext.ts

@@ -18,6 +18,7 @@ import {
   createOpenDelegation,
   decodeDelegations,
   encodeDelegations,
+  ROOT_AUTHORITY,
 } from '../delegation';
 import type {
   Delegation,
@@ -99,7 +100,7 @@ async function signAndPrependRedelegation(
     delegationManager: environment.DelegationManager,
     chainId,
     // Redelegations always inherit from a parent delegation (enforced by
-    // `resolveRedelegationInputs`), so the parent's caveats provide the
+    // `resolveRedelegationArgs`), so the parent's caveats provide the
     // restriction even when the redelegation itself adds no extra caveats.
     // This mirrors `resolveCaveats`, which also allows empty caveats in this
     // case.
@@ -129,7 +130,7 @@ async function signAndPrependRedelegation(
  * @param parameters - The base redelegation parameters.
  * @returns The resolved account, decoded chain and parent (leaf) delegation.
  */
-function resolveRedelegationInputs<
+function resolveRedelegationArgs<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined,
 >(
@@ -139,6 +140,7 @@ function resolveRedelegationInputs<
   account: Account;
   delegations: Delegation[];
   parentDelegation: Delegation;
+  from: Hex;
 } {
   const { account: accountParam = client.account, permissionContext } =
     parameters;
@@ -157,7 +159,14 @@ function resolveRedelegationInputs<
     );
   }
 
-  return { account, delegations, parentDelegation };
+  const isParentOpenDelegation =
+    parentDelegation.authority.toLowerCase() === ROOT_AUTHORITY.toLowerCase();
+
+  const from = isParentOpenDelegation
+    ? account.address
+    : parentDelegation.delegate;
+
+  return { account, delegations, parentDelegation, from };
 }
 
 /**
@@ -208,10 +217,8 @@ export async function redelegatePermissionContext<
 ): Promise<RedelegatePermissionContextReturnType> {
   const { environment, chainId, scope, caveats, salt, to } = parameters;
 
-  const { account, delegations, parentDelegation } = resolveRedelegationInputs(
-    client,
-    parameters,
-  );
+  const { account, delegations, parentDelegation, from } =
+    resolveRedelegationArgs(client, parameters);
 
   trackSmartAccountsKitFunctionCall('redelegatePermissionContext', {
     chainId,
@@ -221,7 +228,7 @@ export async function redelegatePermissionContext<
 
   const unsignedDelegation = createDelegation({
     environment,
-    from: parentDelegation.delegate,
+    from,
     to,
     scope,
     caveats,
@@ -269,10 +276,8 @@ export async function redelegatePermissionContextOpen<
 ): Promise<RedelegatePermissionContextReturnType> {
   const { environment, chainId, scope, caveats, salt } = parameters;
 
-  const { account, delegations, parentDelegation } = resolveRedelegationInputs(
-    client,
-    parameters,
-  );
+  const { account, delegations, parentDelegation, from } =
+    resolveRedelegationArgs(client, parameters);
 
   trackSmartAccountsKitFunctionCall('redelegatePermissionContextOpen', {
     chainId,
@@ -282,7 +287,7 @@ export async function redelegatePermissionContextOpen<
 
   const unsignedDelegation = createOpenDelegation({
     environment,
-    from: parentDelegation.delegate,
+    from,
     scope,
     caveats,
     parentDelegation,

packages/smart-accounts-kit/src/delegation.ts

@@ -336,14 +336,20 @@ const resolveDelegationArgs = (
   const authority = (() => {
     if (!resolvedParentDelegation) {
       if (!options.scope) {
-        throw new Error('Invalid arguments - must specify either parentDelegation, parentPermissionContext, or scope');
+        throw new Error(
+          'Invalid arguments - must specify either parentDelegation, parentPermissionContext, or scope',
+        );
       }
       return ROOT_AUTHORITY;
     }
 
     if (typeof resolvedParentDelegation === 'string') {
-      if (resolvedParentDelegation.toLowerCase() === ROOT_AUTHORITY.toLowerCase()) {
-        throw new Error(`Invalid parent delegation - cannot be ${ROOT_AUTHORITY}`);
+      if (
+        resolvedParentDelegation.toLowerCase() === ROOT_AUTHORITY.toLowerCase()
+      ) {
+        throw new Error(
+          `Invalid parent delegation - cannot be ${ROOT_AUTHORITY}`,
+        );
       }
       return resolvedParentDelegation;
     }

packages/smart-accounts-kit/test/actions/redelegatePermissionContext.test.ts

@@ -9,7 +9,11 @@ import {
   redelegatePermissionContextActions,
 } from '../../src/actions/redelegatePermissionContext';
 import { ScopeType } from '../../src/constants';
-import { createDelegation, encodeDelegations } from '../../src/delegation';
+import {
+  createDelegation,
+  createOpenDelegation,
+  encodeDelegations,
+} from '../../src/delegation';
 import type { SmartAccountsEnvironment } from '../../src/types';
 
 const mockPrivateKey =
@@ -74,7 +78,35 @@ const buildPermissionContextWithParentDelegate = (
     from: '0x1000000000000000000000000000000000000001',
   });
 
-  return encodeDelegations([rootDelegation]);
+  const leafDelegation = createDelegation({
+    environment: mockEnvironment,
+    scope: {
+      type: ScopeType.Erc20TransferAmount,
+      tokenAddress: '0xabc0000000000000000000000000000000000000',
+      maxAmount,
+    },
+    to: parentDelegate,
+    from: '0x2000000000000000000000000000000000000002',
+    parentDelegation: rootDelegation,
+  });
+
+  return encodeDelegations([leafDelegation, rootDelegation]);
+};
+
+const buildPermissionContextWithOpenLeafDelegation = ({
+  maxAmount = 1000n,
+}: { maxAmount?: bigint } = {}) => {
+  const openDelegation = createOpenDelegation({
+    environment: mockEnvironment,
+    scope: {
+      type: ScopeType.Erc20TransferAmount,
+      tokenAddress: '0xabc0000000000000000000000000000000000000',
+      maxAmount,
+    },
+    from: '0x1000000000000000000000000000000000000001',
+  });
+
+  return encodeDelegations([openDelegation]);
 };
 
 describe('redelegatePermissionContext', () => {
@@ -188,6 +220,22 @@ describe('redelegatePermissionContext', () => {
     expect(result.delegation.delegator).to.not.equal(account.address);
   });
 
+  it('should use the account address as from when the leaf delegation is open', async () => {
+    const permissionContext = buildPermissionContextWithOpenLeafDelegation();
+    const newDelegate: Address = '0x2000000000000000000000000000000000000002';
+
+    const result = await redelegatePermissionContext(client, {
+      environment: mockEnvironment,
+      permissionContext,
+      chainId: mockChainId,
+      to: newDelegate,
+    });
+
+    expect(result.delegation.delegator.toLowerCase()).to.equal(
+      account.address.toLowerCase(),
+    );
+  });
+
   it('should allow scope override even with parent', async () => {
     const permissionContext = buildRootPermissionContext();
     const newDelegate: Address = '0x2000000000000000000000000000000000000002';
@@ -360,6 +408,20 @@ describe('redelegatePermissionContextOpen', () => {
     expect(result.delegation.delegator).to.not.equal(account.address);
   });
 
+  it('should use the account address as from when the leaf delegation is open', async () => {
+    const permissionContext = buildPermissionContextWithOpenLeafDelegation();
+
+    const result = await redelegatePermissionContextOpen(client, {
+      environment: mockEnvironment,
+      permissionContext,
+      chainId: mockChainId,
+    });
+
+    expect(result.delegation.delegator.toLowerCase()).to.equal(
+      account.address.toLowerCase(),
+    );
+  });
+
   it('should allow scope override on an open redelegation', async () => {
     const permissionContext = buildRootPermissionContext();