feat(card): migrate delegation methods to CardController

Author: Brunonascdev

app/components/UI/Card/hooks/useCardDelegation.test.ts

@@ -11,10 +11,10 @@ import {
   type Transaction,
 } from '@metamask/keyring-api';
 import Engine from '../../../../core/Engine';
+import { encodeErc20ApproveCalldata } from '../../../../core/Engine/controllers/card-controller/utils/encodeErc20ApproveCalldata';
 import TransactionTypes from '../../../../core/TransactionTypes';
 import Logger from '../../../../util/Logger';
 import { selectSelectedInternalAccountByScope } from '../../../../selectors/multichainAccounts/accounts';
-import { useCardSDK } from '../sdk';
 import { CardNetwork, CardFundingToken } from '../types';
 import { useAnalytics } from '../../../hooks/useAnalytics/useAnalytics';
 import { useEnsureCardNetworkExists } from './useEnsureCardNetworkExists';
@@ -76,8 +76,8 @@ interface SignCardMessageResult {
  * Flow: Token -> Signature -> Approval Transaction -> Completion
  */
 export const useCardDelegation = (token?: CardFundingToken | null) => {
-  const { sdk } = useCardSDK();
-  const { KeyringController, TransactionController } = Engine.context;
+  const { KeyringController, TransactionController, CardController } =
+    Engine.context;
   const { ensureNetworkExists } = useEnsureCardNetworkExists();
   const selectAccountByScope = useSelector(
     selectSelectedInternalAccountByScope,
@@ -133,7 +133,7 @@ export const useCardDelegation = (token?: CardFundingToken | null) => {
       signatureMessage: string,
       delegationJWTToken: string,
     ) => {
-      if (!sdk || !token?.delegationContract) {
+      if (!token?.delegationContract) {
         throw new Error('Missing token configuration');
       }
 
@@ -154,7 +154,7 @@ export const useCardDelegation = (token?: CardFundingToken | null) => {
         token.decimals ?? 18,
       ).toString();
 
-      const transactionData = sdk.encodeApproveTransaction(
+      const transactionData = encodeErc20ApproveCalldata(
         token.delegationContract,
         amountInMinimalUnits,
       );
@@ -193,7 +193,7 @@ export const useCardDelegation = (token?: CardFundingToken | null) => {
             async (transactionMeta) => {
               if (transactionMeta.status === TransactionStatus.confirmed) {
                 try {
-                  await sdk.completeDelegation({
+                  await CardController.approveFunding({
                     address,
                     network: params.network,
                     currency: params.currency.toLowerCase(),
@@ -234,7 +234,7 @@ export const useCardDelegation = (token?: CardFundingToken | null) => {
         rethrowAsUserCancelledIfApplicable(error);
       }
     },
-    [sdk, token, TransactionController, ensureNetworkExists],
+    [token, TransactionController, ensureNetworkExists, CardController],
   );
 
   /**
@@ -256,7 +256,7 @@ export const useCardDelegation = (token?: CardFundingToken | null) => {
       signatureMessage: string,
       delegationJWTToken: string,
     ) => {
-      if (!sdk || !token?.delegationContract) {
+      if (!token?.delegationContract) {
         throw new Error('Missing token configuration');
       }
       if (!token?.stagingTokenAddress && !token?.address) {
@@ -371,7 +371,7 @@ export const useCardDelegation = (token?: CardFundingToken | null) => {
         });
 
         // Complete the delegation with the backend API after confirmation
-        await sdk.completeDelegation({
+        await CardController.approveFunding({
           address,
           network: params.network,
           currency: params.currency.toLowerCase(),
@@ -391,7 +391,7 @@ export const useCardDelegation = (token?: CardFundingToken | null) => {
         rethrowAsUserCancelledIfApplicable(error);
       }
     },
-    [sdk, token],
+    [token, CardController],
   );
 
   const signSolanaMessage = useCallback(
@@ -438,10 +438,6 @@ export const useCardDelegation = (token?: CardFundingToken | null) => {
    */
   const submitDelegation = useCallback(
     async (params: DelegationParams) => {
-      if (!sdk) {
-        throw new Error('Card SDK not available');
-      }
-
       setState({ isLoading: true, error: null });
 
       const metricsProps = {
@@ -473,13 +469,13 @@ export const useCardDelegation = (token?: CardFundingToken | null) => {
           throw new Error('No account found');
         }
 
-        // Step 1: Generate delegation token (pass faucet flag if user needs gas)
-        const { token: delegationJWTToken, nonce } =
-          await sdk.generateDelegationToken(
-            params.network,
+        // Step 1: Delegation session (pass faucet flag if user needs gas)
+        const { delegationToken: delegationJWTToken, nonce } =
+          await CardController.fetchDelegationChallenge({
+            network: params.network,
             address,
-            needsFaucet,
-          );
+            faucet: needsFaucet,
+          });
 
         // Step 2: Generate and sign SIWE message
         const signatureMessage = generateSignatureMessage(
@@ -548,7 +544,6 @@ export const useCardDelegation = (token?: CardFundingToken | null) => {
       }
     },
     [
-      sdk,
       selectAccountByScope,
       generateSignatureMessage,
       KeyringController,
@@ -559,6 +554,7 @@ export const useCardDelegation = (token?: CardFundingToken | null) => {
       trackEvent,
       createEventBuilder,
       needsFaucet,
+      CardController,
     ],
   );
 

app/components/UI/Card/hooks/useCardDelegation.ts

@@ -1646,13 +1646,6 @@ export class CardSDK {
       },
     );
 
-  encodeApproveTransaction = (spender: string, value: string): string => {
-    const approvalInterface = new ethers.utils.Interface([
-      'function approve(address spender, uint256 value)',
-    ]);
-    return approvalInterface.encodeFunctionData('approve', [spender, value]);
-  };
-
   /**
    * Validate delegation settings response
    */

app/components/UI/Card/sdk/CardSDK.ts

@@ -1514,6 +1514,50 @@ describe('CardController — data pass-throughs', () => {
     });
   });
 
+  describe('fetchDelegationChallenge', () => {
+    it('delegates to provider.fetchDelegationChallenge', async () => {
+      const mockFetch = jest.fn().mockResolvedValue({
+        delegationToken: 'jwt',
+        nonce: 'nonce-1',
+        expiresAt: '2099-01-01',
+      });
+      const provider = buildMockProvider({
+        fetchDelegationChallenge: mockFetch,
+      });
+      const { controller } = buildAuthenticatedController(provider);
+
+      const result = await controller.fetchDelegationChallenge({
+        network: 'linea',
+        address: '0xabc',
+        faucet: true,
+      });
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        { network: 'linea', address: '0xabc', faucet: true },
+        mockTokenSet,
+      );
+      expect(result).toStrictEqual({
+        delegationToken: 'jwt',
+        nonce: 'nonce-1',
+        expiresAt: '2099-01-01',
+      });
+    });
+
+    it('throws when provider does not support fetchDelegationChallenge', async () => {
+      const provider = buildMockProvider({
+        fetchDelegationChallenge: undefined,
+      });
+      const { controller } = buildAuthenticatedController(provider);
+
+      await expect(
+        controller.fetchDelegationChallenge({
+          network: 'linea',
+          address: '0xabc',
+        }),
+      ).rejects.toThrow('Delegation challenge not supported');
+    });
+  });
+
   describe('createGoogleWalletProvisioningRequest', () => {
     it('delegates to provider', async () => {
       const mockCreate = jest

app/core/Engine/controllers/card-controller/CardController.test.ts

@@ -1,6 +1,5 @@
 import { BaseController, type StateMetadata } from '@metamask/base-controller';
-import { TransactionType } from '@metamask/transaction-controller';
-import { numberToHex, type Hex, type Json } from '@metamask/utils';
+import { type Json } from '@metamask/utils';
 import Logger from '../../../../util/Logger';
 import {
   CARD_CONTROLLER_NAME,
@@ -30,9 +29,9 @@ import {
   type CashbackWithdrawEstimationResponse,
   type CashbackWithdrawParams,
   type CashbackWithdrawResponse,
+  type DelegationChallengeResponse,
   type FundingApprovalParams,
   type ICardProvider,
-  type WalletOperations,
 } from './provider-types';
 import { CardTokenStore } from './CardTokenStore';
 import { isEthAccount } from '../../../Multichain/utils';
@@ -838,39 +837,23 @@ export class CardController extends BaseController<
         'Funding approval not supported',
       );
     }
-    const wallet = this.#buildWalletOperations();
-    return provider.approveFunding(params, tokens, wallet);
+    return provider.approveFunding(params, tokens);
   }
 
-  #buildWalletOperations(): WalletOperations {
-    return {
-      signMessage: async (address: string, message: string) => {
-        const hex = `0x${Buffer.from(message, 'utf8').toString('hex')}`;
-        return this.messenger.call('KeyringController:signPersonalMessage', {
-          data: hex,
-          from: address,
-        });
-      },
-      submitTransaction: async (txParams, chainId) => {
-        const chainNumber = parseInt(chainId.split(':')[1], 10);
-        const hexChainId = numberToHex(chainNumber) as Hex;
-        const networkClientId = this.messenger.call(
-          'NetworkController:findNetworkClientIdByChainId',
-          hexChainId,
-        );
-        const { result } = await this.messenger.call(
-          'TransactionController:addTransaction',
-          txParams,
-          {
-            networkClientId,
-            origin: 'metamask',
-            type: TransactionType.tokenMethodApprove,
-            requireApproval: true,
-          },
-        );
-        return result;
-      },
-    };
+  async fetchDelegationChallenge(params: {
+    network: string;
+    address: string;
+    faucet?: boolean;
+  }): Promise<DelegationChallengeResponse> {
+    const tokens = await this.requireValidTokens();
+    const provider = this.getActiveProvider();
+    if (!provider.fetchDelegationChallenge) {
+      throw new CardProviderError(
+        CardProviderErrorCode.Unknown,
+        'Delegation challenge not supported',
+      );
+    }
+    return provider.fetchDelegationChallenge(params, tokens);
   }
 
   // -- Push Provisioning --

app/core/Engine/controllers/card-controller/CardController.ts

@@ -224,20 +224,22 @@ export function emptyCardHomeData(): CardHomeData {
 
 // -- Funding --
 
-export interface WalletOperations {
-  signMessage(address: string, message: string): Promise<string>;
-  submitTransaction(
-    params: { to: string; data: string; from: string },
-    chainId: CaipChainId,
-  ): Promise<string>;
-}
-
 export interface FundingApprovalParams {
   address: string;
   amount: string;
   currency: string;
   network: string;
-  faucet?: boolean;
+  txHash: string;
+  sigHash: string;
+  sigMessage: string;
+  token: string;
+}
+
+/** Response from initiating a delegation session (GET `/v1/delegation/token`). */
+export interface DelegationChallengeResponse {
+  delegationToken: string;
+  nonce: string;
+  expiresAt: string;
 }
 
 export interface CardFundingOption {
@@ -360,10 +362,17 @@ export interface ICardProvider {
   ): Promise<void>;
   getFundingConfig?(tokens: CardAuthTokens): Promise<CardFundingConfig>;
 
+  /**
+   * Fetches a short-lived delegation session (nonce + JWT) before SIWE + on-chain approve.
+   */
+  fetchDelegationChallenge?(
+    params: { network: string; address: string; faucet?: boolean },
+    tokens: CardAuthTokens,
+  ): Promise<DelegationChallengeResponse>;
+
   approveFunding?(
     params: FundingApprovalParams,
     tokens: CardAuthTokens,
-    wallet: WalletOperations,
   ): Promise<void>;
 
   getCashbackWallet?(tokens: CardAuthTokens): Promise<CashbackWalletResponse>;