MetaMask
diff --git a/‎app/components/UI/Predict/controllers/PredictController.test.ts‎
Lines changed: 148 additions & 17 deletions b/‎app/components/UI/Predict/controllers/PredictController.test.ts‎
Lines changed: 148 additions & 17 deletions
diff --git a/‎app/components/UI/Predict/controllers/PredictController.ts‎
Lines changed: 68 additions & 15 deletions b/‎app/components/UI/Predict/controllers/PredictController.ts‎
Lines changed: 68 additions & 15 deletions
diff --git a/‎app/components/UI/Predict/hooks/usePredictAccountState.test.ts‎
Lines changed: 1 addition & 0 deletions b/‎app/components/UI/Predict/hooks/usePredictAccountState.test.ts‎
Lines changed: 1 addition & 0 deletions
@@ -278,8 +278,18 @@ describe('PredictController', () => {
       createOptimisticPositionFromPreview: jest.fn(),
       clearOptimisticPosition: jest.fn(),
       getCryptoTargetPrice: jest.fn(),
+      invalidateAccountState: jest.fn(),
+      beforePublishDepositWalletDeposit: jest.fn(),
+      syncDepositWalletBalanceAllowanceForDepositTransaction: jest.fn(),
     } as unknown as jest.Mocked<PolymarketProvider>;
 
+    mockPolymarketProvider.beforePublishDepositWalletDeposit.mockResolvedValue(
+      true,
+    );
+    mockPolymarketProvider.syncDepositWalletBalanceAllowanceForDepositTransaction.mockResolvedValue(
+      undefined,
+    );
+
     // Default safe mocks for async fire-and-forget methods
     // (prevents unhandled rejections when payWithAnyTokenConfirmation is
     // triggered by onBuyPaymentTokenChange but the async chain completes
@@ -4885,6 +4895,38 @@ describe('PredictController', () => {
       });
     });
 
+    it('invalidates account state and syncs deposit-wallet balance allowance after confirmed deposits', async () => {
+      await withController(async ({ controller, messenger }) => {
+        const transactionMeta = createPredictTransactionMeta({
+          nestedType: TransactionType.predictDeposit,
+          status: TransactionStatus.confirmed,
+          from: accountAddress,
+        });
+
+        controller.updateStateForTesting((state) => {
+          state.pendingDeposits = {
+            [accountAddress]: 'pending',
+          };
+        });
+
+        messenger.publish('TransactionController:transactionStatusUpdated', {
+          transactionMeta,
+        } as { transactionMeta: TransactionMeta });
+
+        await Promise.resolve();
+
+        expect(
+          mockPolymarketProvider.invalidateAccountState,
+        ).toHaveBeenCalledWith(accountAddress);
+        expect(
+          mockPolymarketProvider.syncDepositWalletBalanceAllowanceForDepositTransaction,
+        ).toHaveBeenCalledWith({
+          transactionMeta,
+          signerAddress: accountAddress,
+        });
+      });
+    });
+
     it('clears only sender pending deposit when selected account differs', () => {
       withController(({ controller, messenger }) => {
         const selectedAddress = accountAddress;
@@ -5721,6 +5763,7 @@ describe('PredictController', () => {
       const mockAccountState = {
         address: '0xProxyAddress' as `0x${string}`,
         isDeployed: true,
+        walletType: 'safe' as const,
         balance: 100.5,
       };
 
@@ -6140,18 +6183,24 @@ describe('PredictController', () => {
   });
 
   describe('beforePublish', () => {
-    it('passes through by default', async () => {
+    it('delegates to provider deposit-wallet preflight', async () => {
       await withController(async ({ controller }) => {
-        const result = await controller.beforePublish({
-          transactionMeta: {
-            id: 'tx-1',
-            txParams: {
-              from: MOCK_ADDRESS,
-            },
-          } as TransactionMeta,
-        });
+        const transactionMeta = {
+          id: 'tx-before-publish',
+          txParams: {
+            from: '0x1234567890123456789012345678901234567890',
+          },
+        } as TransactionMeta;
+
+        const result = await controller.beforePublish({ transactionMeta });
 
         expect(result).toBe(true);
+        expect(
+          mockPolymarketProvider.beforePublishDepositWalletDeposit,
+        ).toHaveBeenCalledWith({
+          transactionMeta,
+          getSigner: expect.any(Function),
+        });
       });
     });
   });
@@ -9077,8 +9126,8 @@ describe('PredictController', () => {
         ],
       }) as any;
 
-    it('places the order when depositAndOrder transaction is confirmed and preview exists', () => {
-      withController(({ controller, messenger }) => {
+    it('places the order when depositAndOrder transaction is confirmed and preview exists', async () => {
+      await withController(async ({ controller, messenger }) => {
         const preview = createMockOrderPreview();
         const placeOrderSpy = jest
           .spyOn(controller, 'placeOrder')
@@ -9126,6 +9175,9 @@ describe('PredictController', () => {
           },
         } as { transactionMeta: TransactionMeta });
 
+        await Promise.resolve();
+        await Promise.resolve();
+
         expect(placeOrderSpy).toHaveBeenCalledWith({
           analyticsProperties: { marketId: 'market-1' },
           preview,
@@ -9135,8 +9187,78 @@ describe('PredictController', () => {
       });
     });
 
-    it('forwards activeAbTests to placeOrder when depositAndOrder is confirmed', () => {
-      withController(({ controller, messenger }) => {
+    it('waits for deposit-wallet balance allowance sync before placing depositAndOrder', async () => {
+      await withController(async ({ controller, messenger }) => {
+        const preview = createMockOrderPreview();
+        const placeOrderSpy = jest
+          .spyOn(controller, 'placeOrder')
+          .mockResolvedValue({
+            success: true,
+            response: {
+              id: 'order-123',
+              spentAmount: '100',
+              receivedAmount: '200',
+            },
+          } as any);
+        let resolveSync: () => void = jest.fn();
+        const syncPromise = new Promise<void>((resolve) => {
+          resolveSync = resolve;
+        });
+        mockPolymarketProvider.syncDepositWalletBalanceAllowanceForDepositTransaction.mockReturnValueOnce(
+          syncPromise,
+        );
+
+        setActiveOrderForTest(controller, {
+          state: ActiveOrderState.DEPOSITING,
+          transactionId: 'tx-1',
+        });
+        (
+          controller as unknown as {
+            pendingOrderPreviews: {
+              [transactionId: string]: {
+                preview: OrderPreview;
+                signerAddress: string;
+              };
+            };
+          }
+        ).pendingOrderPreviews['tx-1'] = {
+          preview,
+          signerAddress: accountAddress,
+        };
+
+        messenger.publish('TransactionController:transactionStatusUpdated', {
+          transactionMeta: {
+            ...createPredictTransactionMeta({
+              nestedType: TransactionType.predictDeposit,
+              status: TransactionStatus.confirmed,
+            }),
+            type: TransactionType.predictDepositAndOrder,
+            nestedTransactions: [
+              { type: TransactionType.predictDepositAndOrder },
+            ],
+          },
+        } as { transactionMeta: TransactionMeta });
+
+        await Promise.resolve();
+
+        expect(placeOrderSpy).not.toHaveBeenCalled();
+
+        resolveSync();
+        await Promise.resolve();
+        await Promise.resolve();
+
+        expect(placeOrderSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            preview,
+            address: accountAddress,
+            transactionId: 'tx-1',
+          }),
+        );
+      });
+    });
+
+    it('forwards activeAbTests to placeOrder when depositAndOrder is confirmed', async () => {
+      await withController(async ({ controller, messenger }) => {
         const preview = createMockOrderPreview();
         const abTests = [
           { key: 'predict-pwat-experiment', value: 'treatment' },
@@ -9184,6 +9306,9 @@ describe('PredictController', () => {
           },
         } as { transactionMeta: TransactionMeta });
 
+        await Promise.resolve();
+        await Promise.resolve();
+
         expect(placeOrderSpy).toHaveBeenCalledWith(
           expect.objectContaining({ activeAbTests: abTests }),
         );
@@ -9645,8 +9770,8 @@ describe('PredictController', () => {
       });
     });
 
-    it('does not update activeBuyOrder when deposit confirms for a different active order', () => {
-      withController(({ controller, messenger }) => {
+    it('does not update activeBuyOrder when deposit confirms for a different active order', async () => {
+      await withController(async ({ controller, messenger }) => {
         setActiveOrderForTest(controller, {
           state: ActiveOrderState.PREVIEW,
         });
@@ -9694,6 +9819,9 @@ describe('PredictController', () => {
           },
         } as { transactionMeta: TransactionMeta });
 
+        await Promise.resolve();
+        await Promise.resolve();
+
         expect(placeOrderSpy).toHaveBeenCalledWith({
           analyticsProperties: { marketId: 'market-1' },
           preview,
@@ -9805,8 +9933,8 @@ describe('PredictController', () => {
           ],
         }) as any;
 
-      it('forwards the transaction address to placeOrder when depositAndOrder confirms after account switch', () => {
-        withController(({ controller, messenger }) => {
+      it('forwards the transaction address to placeOrder when depositAndOrder confirms after account switch', async () => {
+        await withController(async ({ controller, messenger }) => {
           const preview = createMockOrderPreview();
           const placeOrderSpy = jest
             .spyOn(controller, 'placeOrder')
@@ -9854,6 +9982,9 @@ describe('PredictController', () => {
             },
           } as { transactionMeta: TransactionMeta });
 
+          await Promise.resolve();
+          await Promise.resolve();
+
           expect(placeOrderSpy).toHaveBeenCalledWith({
             analyticsProperties: { marketId: 'market-2' },
             preview,
 
@@ -2144,6 +2144,38 @@ export class PredictController extends BaseController<
     });
   }
 
+  private async syncDepositWalletBalanceAllowanceIfNeeded({
+    transactionMeta,
+    address,
+  }: {
+    transactionMeta: TransactionMeta;
+    address: string;
+  }): Promise<void> {
+    try {
+      await this.provider.syncDepositWalletBalanceAllowanceForDepositTransaction(
+        {
+          transactionMeta,
+          signerAddress: address,
+        },
+      );
+    } catch (error) {
+      DevLogger.log(
+        'PredictController: Deposit wallet balance-allowance sync failed',
+        {
+          error: error instanceof Error ? error.message : 'Unknown error',
+          transactionId: transactionMeta.id,
+        },
+      );
+      Logger.error(
+        ensureError(error),
+        this.getErrorContext('syncDepositWalletBalanceAllowanceIfNeeded', {
+          operation: 'deposit_wallet_balance_allowance_sync',
+          transactionId: transactionMeta.id,
+        }),
+      );
+    }
+  }
+
   private handleTransactionSideEffects(
     type: PredictTransactionEventType,
     status: PredictTransactionEventStatus,
@@ -2157,6 +2189,20 @@ export class PredictController extends BaseController<
       this.clearPendingDepositForAddress({ address });
     }
 
+    let depositWalletSyncPromise: Promise<void> | undefined;
+    if (
+      (type === 'deposit' || type === 'depositAndOrder') &&
+      status === 'confirmed'
+    ) {
+      this.provider.invalidateAccountState(address);
+      depositWalletSyncPromise = this.syncDepositWalletBalanceAllowanceIfNeeded(
+        {
+          transactionMeta,
+          address,
+        },
+      );
+    }
+
     if (type === 'depositAndOrder' && status === 'confirmed') {
       const transactionId = transactionMeta.id;
       const pendingOrder = transactionId
@@ -2186,20 +2232,24 @@ export class PredictController extends BaseController<
         activeAbTests: pendingActiveAbTests,
       } = pendingOrder;
 
-      this.placeOrder({
-        analyticsProperties: pendingAnalytics,
-        activeAbTests: pendingActiveAbTests,
-        preview,
-        address: signerAddress,
-        transactionId,
-      }).catch((error) => {
-        Logger.error(
-          ensureError(error),
-          this.getErrorContext('handleTransactionSideEffects', {
-            operation: 'placeOrder',
+      (depositWalletSyncPromise ?? Promise.resolve())
+        .then(() =>
+          this.placeOrder({
+            analyticsProperties: pendingAnalytics,
+            activeAbTests: pendingActiveAbTests,
+            preview,
+            address: signerAddress,
+            transactionId,
           }),
-        );
-      });
+        )
+        .catch((error) => {
+          Logger.error(
+            ensureError(error),
+            this.getErrorContext('handleTransactionSideEffects', {
+              operation: 'placeOrder',
+            }),
+          );
+        });
     }
 
     if (type === 'depositAndOrder' && status === 'failed') {
@@ -2621,10 +2671,13 @@ export class PredictController extends BaseController<
     }
   }
 
-  public async beforePublish(_request: {
+  public async beforePublish(request: {
     transactionMeta: TransactionMeta;
   }): Promise<boolean> {
-    return true;
+    return this.provider.beforePublishDepositWalletDeposit({
+      transactionMeta: request.transactionMeta,
+      getSigner: (address?: string) => this.getSigner(address),
+    });
   }
 
   public async beforeSign(request: {
 
@@ -63,6 +63,7 @@ describe('usePredictAccountState', () => {
   const mockAccountState = {
     address: '0x1234567890abcdef1234567890abcdef12345678',
     isDeployed: true,
+    walletType: 'safe' as const,
   };
 
   beforeEach(() => {