MetaMask
diff --git a/‎app/components/UI/Predict/providers/polymarket/PolymarketProvider.test.ts‎
Lines changed: 409 additions & 2 deletions b/‎app/components/UI/Predict/providers/polymarket/PolymarketProvider.test.ts‎
Lines changed: 409 additions & 2 deletions
diff --git a/‎app/components/UI/Predict/providers/polymarket/PolymarketProvider.ts‎
Lines changed: 562 additions & 324 deletions b/‎app/components/UI/Predict/providers/polymarket/PolymarketProvider.ts‎
Lines changed: 562 additions & 324 deletions
diff --git a/‎app/components/UI/Predict/providers/polymarket/constants.ts‎
Lines changed: 25 additions & 0 deletions b/‎app/components/UI/Predict/providers/polymarket/constants.ts‎
Lines changed: 25 additions & 0 deletions
diff --git a/‎app/components/UI/Predict/providers/polymarket/preflight/claim.ts‎
Lines changed: 220 additions & 0 deletions b/‎app/components/UI/Predict/providers/polymarket/preflight/claim.ts‎
Lines changed: 220 additions & 0 deletions
diff --git a/‎app/components/UI/Predict/providers/polymarket/preflight/compileRequirementTransactions.test.ts‎
Lines changed: 39 additions & 0 deletions b/‎app/components/UI/Predict/providers/polymarket/preflight/compileRequirementTransactions.test.ts‎
Lines changed: 39 additions & 0 deletions
diff --git a/‎app/components/UI/Predict/providers/polymarket/preflight/compileRequirementTransactions.ts‎
Lines changed: 32 additions & 0 deletions b/‎app/components/UI/Predict/providers/polymarket/preflight/compileRequirementTransactions.ts‎
Lines changed: 32 additions & 0 deletions
@@ -4,6 +4,9 @@ export const POLYMARKET_PROVIDER_ID = 'polymarket';
 
 export const POLYMARKET_TERMS_URL = 'https://polymarket.com/tos';
 
+export const DEFAULT_CLOB_BASE_URL = 'https://clob.polymarket.com';
+export const LEGACY_V2_CLOB_BASE_URL = 'https://clob-v2.polymarket.com';
+
 /**
  * Default slippage for market orders.
  */
@@ -81,6 +84,28 @@ export const MATIC_CONTRACTS: ContractConfig = {
   conditionalTokens: '0x4D97DCd97eC945f40cF65F87097ACe5EA0476045',
 };
 
+export const MATIC_CONTRACTS_V2: ContractConfig = {
+  exchange: '0xE111180000d2663C0091e4f400237545B87B996B',
+  negRiskAdapter: '0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296',
+  negRiskExchange: '0xe2222d279d744050d28e00520010520000310F59',
+  collateral: '0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB',
+  conditionalTokens: '0x4D97DCd97eC945f40cF65F87097ACe5EA0476045',
+};
+
+export const USDC_E_ADDRESS = MATIC_CONTRACTS.collateral;
+
+export const COLLATERAL_ONRAMP_ADDRESS =
+  '0x93070a847efEf7F70739046A929D47a521F5B8ee';
+
+export const COLLATERAL_OFFRAMP_ADDRESS =
+  '0x2957922Eb93258b93368531d39fAcCA3B4dC5854';
+
+export const CTF_COLLATERAL_ADAPTER_ADDRESS =
+  '0xADa100874d00e3331D00F2007a9c336a65009718';
+
+export const NEG_RISK_CTF_COLLATERAL_ADAPTER_ADDRESS =
+  '0xAdA200001000ef00D07553cEE7006808F895c6F1';
+
 export const POLYGON_USDC_CAIP_ASSET_ID =
   `${POLYGON_MAINNET_CAIP_CHAIN_ID}/erc20:${MATIC_CONTRACTS.collateral}` as const;
 
 
@@ -0,0 +1,220 @@
+import { TransactionType } from '@metamask/transaction-controller';
+import { parseUnits } from 'ethers/lib/utils';
+import type { PredictPosition } from '../../../types';
+import type { Signer } from '../../types';
+import {
+  HASH_ZERO_BYTES32,
+  MIN_COLLATERAL_BALANCE_FOR_CLAIM,
+} from '../constants';
+import {
+  POLYMARKET_V2_PROTOCOL,
+  type PolymarketProtocolDefinition,
+} from '../protocol/definitions';
+import { OperationType, type SafeTransaction } from '../safe/types';
+import { encodeRedeemPositions } from '../utils';
+import {
+  buildSignedSafeExecution,
+  buildUnwrapTransaction,
+  compileAllowanceMaintenanceTransactions,
+  getRawTokenBalance,
+} from './core';
+import { inspectMissingRequirements } from './inspectMissingRequirements';
+import {
+  getCanonicalV2AllowanceRequirements,
+  type V2AllowanceRequirement,
+} from './v2AllowanceRequirements';
+
+const MIN_GAS_STATION_USDCE_BALANCE_RAW = BigInt(
+  parseUnits(MIN_COLLATERAL_BALANCE_FOR_CLAIM.toString(), 6).toString(),
+);
+
+type PolymarketV2ProtocolDefinition = Extract<
+  PolymarketProtocolDefinition,
+  { key: 'v2' }
+>;
+
+function buildClaimSubtransactions({
+  positions,
+  protocol,
+}: {
+  positions: PredictPosition[];
+  protocol: PolymarketV2ProtocolDefinition;
+}): SafeTransaction[] {
+  return positions.map((position) => ({
+    to: position.negRisk
+      ? protocol.claim.negRiskTarget
+      : protocol.claim.standardTarget,
+    data: encodeRedeemPositions({
+      collateralToken: protocol.collateral.claimToken,
+      parentCollectionId: HASH_ZERO_BYTES32,
+      conditionId: position.outcomeId,
+      indexSets: [1, 2],
+    }),
+    operation: OperationType.Call,
+    value: '0',
+  }));
+}
+
+export function getClaimRequirements({
+  positions,
+  protocol = POLYMARKET_V2_PROTOCOL,
+}: {
+  positions: PredictPosition[];
+  protocol?: PolymarketV2ProtocolDefinition;
+}): V2AllowanceRequirement[] {
+  const requiresStandardAdapter = positions.some(
+    (position) => !position.negRisk,
+  );
+  const requiresNegRiskAdapter = positions.some((position) => position.negRisk);
+
+  return [
+    ...getCanonicalV2AllowanceRequirements(protocol),
+    ...(requiresStandardAdapter
+      ? [
+          {
+            type: 'erc1155-operator' as const,
+            tokenAddress: protocol.contracts.conditionalTokens,
+            operator: protocol.claim.standardTarget,
+          },
+        ]
+      : []),
+    ...(requiresNegRiskAdapter
+      ? [
+          {
+            type: 'erc1155-operator' as const,
+            tokenAddress: protocol.contracts.conditionalTokens,
+            operator: protocol.claim.negRiskTarget,
+          },
+        ]
+      : []),
+  ];
+}
+
+export interface ClaimPlan {
+  gasStationDeficit: bigint;
+  safeUsdceBalance: bigint;
+  eoaUsdceBalance: bigint;
+  missingRequirements: V2AllowanceRequirement[];
+  transactions: SafeTransaction[];
+}
+
+export async function planClaim({
+  signer,
+  positions,
+  safeAddress,
+  protocol = POLYMARKET_V2_PROTOCOL,
+}: {
+  signer: Signer;
+  positions: PredictPosition[];
+  safeAddress: string;
+  protocol?: PolymarketV2ProtocolDefinition;
+}): Promise<ClaimPlan> {
+  const [missingRequirements, safeUsdceBalance, eoaUsdceBalance] =
+    await Promise.all([
+      inspectMissingRequirements({
+        address: safeAddress,
+        requirements: getClaimRequirements({ positions, protocol }),
+      }),
+      getRawTokenBalance({
+        address: safeAddress,
+        tokenAddress: protocol.collateral.legacyUsdceToken,
+      }),
+      getRawTokenBalance({
+        address: signer.address,
+        tokenAddress: protocol.collateral.legacyUsdceToken,
+      }),
+    ]);
+
+  const gasStationDeficit =
+    eoaUsdceBalance >= MIN_GAS_STATION_USDCE_BALANCE_RAW
+      ? 0n
+      : MIN_GAS_STATION_USDCE_BALANCE_RAW - eoaUsdceBalance;
+
+  const transactions = compileClaimTransactions({
+    protocol,
+    signer,
+    positions,
+    safeAddress,
+    missingRequirements,
+    safeUsdceBalance,
+    gasStationDeficit,
+  });
+
+  return {
+    gasStationDeficit,
+    safeUsdceBalance,
+    eoaUsdceBalance,
+    missingRequirements,
+    transactions,
+  };
+}
+
+function compileClaimTransactions({
+  protocol = POLYMARKET_V2_PROTOCOL,
+  signer,
+  positions,
+  safeAddress,
+  missingRequirements,
+  safeUsdceBalance,
+  gasStationDeficit,
+}: {
+  protocol?: PolymarketV2ProtocolDefinition;
+  signer: Signer;
+  positions: PredictPosition[];
+  safeAddress: string;
+  missingRequirements: V2AllowanceRequirement[];
+  safeUsdceBalance: bigint;
+  gasStationDeficit: bigint;
+}): SafeTransaction[] {
+  const transactions = compileAllowanceMaintenanceTransactions({
+    protocol,
+    safeAddress,
+    missingRequirements,
+    usdceBalance: safeUsdceBalance,
+  });
+
+  transactions.push(
+    ...buildClaimSubtransactions({
+      positions,
+      protocol,
+    }),
+  );
+
+  const unwrapTransaction = buildUnwrapTransaction({
+    recipientAddress: signer.address,
+    amount: gasStationDeficit,
+    protocol,
+  });
+
+  if (unwrapTransaction) {
+    transactions.push(unwrapTransaction);
+  }
+
+  return transactions;
+}
+
+export async function buildClaimTransaction({
+  signer,
+  positions,
+  safeAddress,
+  protocol = POLYMARKET_V2_PROTOCOL,
+}: {
+  signer: Signer;
+  positions: PredictPosition[];
+  safeAddress: string;
+  protocol?: PolymarketV2ProtocolDefinition;
+}) {
+  const plan = await planClaim({
+    signer,
+    positions,
+    safeAddress,
+    protocol,
+  });
+
+  return buildSignedSafeExecution({
+    signer,
+    safeAddress,
+    transactions: plan.transactions,
+    type: TransactionType.predictClaim,
+  });
+}
@@ -0,0 +1,39 @@
+jest.mock('../utils', () => ({
+  encodeApprove: jest.fn(({ spender }) => `approve:${spender}`),
+  encodeErc1155Approve: jest.fn(({ spender }) => `setApproval:${spender}`),
+}));
+
+import { compileRequirementTransactions } from './compileRequirementTransactions';
+import type { V2AllowanceRequirement } from './v2AllowanceRequirements';
+
+describe('compileRequirementTransactions', () => {
+  it('compiles erc20 approvals and erc1155 operator approvals in order', () => {
+    const requirements: V2AllowanceRequirement[] = [
+      {
+        type: 'erc20-allowance',
+        tokenAddress: '0x1000000000000000000000000000000000000000',
+        spender: '0x2000000000000000000000000000000000000000',
+      },
+      {
+        type: 'erc1155-operator',
+        tokenAddress: '0x3000000000000000000000000000000000000000',
+        operator: '0x4000000000000000000000000000000000000000',
+      },
+    ];
+
+    expect(compileRequirementTransactions(requirements)).toEqual([
+      {
+        to: '0x1000000000000000000000000000000000000000',
+        data: 'approve:0x2000000000000000000000000000000000000000',
+        operation: 0,
+        value: '0',
+      },
+      {
+        to: '0x3000000000000000000000000000000000000000',
+        data: 'setApproval:0x4000000000000000000000000000000000000000',
+        operation: 0,
+        value: '0',
+      },
+    ]);
+  });
+});
@@ -0,0 +1,32 @@
+import { ethers } from 'ethers';
+import { OperationType, type SafeTransaction } from '../safe/types';
+import { encodeApprove, encodeErc1155Approve } from '../utils';
+import type { V2AllowanceRequirement } from './v2AllowanceRequirements';
+
+export function compileRequirementTransactions(
+  requirements: V2AllowanceRequirement[],
+): SafeTransaction[] {
+  return requirements.map((requirement) => {
+    if (requirement.type === 'erc20-allowance') {
+      return {
+        to: requirement.tokenAddress,
+        data: encodeApprove({
+          spender: requirement.spender,
+          amount: ethers.constants.MaxUint256.toBigInt(),
+        }),
+        operation: OperationType.Call,
+        value: '0',
+      };
+    }
+
+    return {
+      to: requirement.tokenAddress,
+      data: encodeErc1155Approve({
+        spender: requirement.operator,
+        approved: true,
+      }),
+      operation: OperationType.Call,
+      value: '0',
+    };
+  });
+}