@rhinestone/deposit-modal 0.2.4 → 0.2.5-alpha.0

package/dist/chunk-LHOHM67Z.mjs

@@ -0,0 +1,234 @@
+import {
+  SAFE_ABI
+} from "./chunk-J2SWZSXL.mjs";
+
+// src/core/polymarket-safe.ts
+import {
+  concat,
+  encodeAbiParameters,
+  encodeFunctionData,
+  encodePacked,
+  erc20Abi,
+  formatUnits,
+  getAddress,
+  getCreate2Address,
+  keccak256,
+  parseAbi,
+  parseEventLogs,
+  pad,
+  toHex,
+  zeroAddress
+} from "viem";
+var POLYMARKET_POLYGON_CHAIN_ID = 137;
+var POLYMARKET_SAFE_FACTORY_ADDRESS = "0xaacFeEa03eb1561C4e67d661e40682Bd20E3541b";
+var POLYMARKET_SAFE_INIT_CODE_HASH = "0x2bce2127ff07fb632d16c8347c4ebf501f4841168bed00d9e6ef715ddb6fcecf";
+var POLYMARKET_USDCE_ADDRESS = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+var POLYMARKET_PUSD_ADDRESS = "0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB";
+var POLYMARKET_COLLATERAL_OFFRAMP_ADDRESS = "0x2957922Eb93258b93368531d39fAcCA3B4dC5854";
+var SAFE_MULTI_SEND_CALL_ONLY_ADDRESS = "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D";
+var COLLATERAL_OFFRAMP_ABI = parseAbi([
+  "function unwrap(address _asset, address _to, uint256 _amount)"
+]);
+var MULTI_SEND_ABI = parseAbi(["function multiSend(bytes transactions)"]);
+function derivePolymarketSafeAddress(owner) {
+  const checksummedOwner = getAddress(owner);
+  const salt = keccak256(
+    encodeAbiParameters([{ type: "address" }], [checksummedOwner])
+  );
+  return getCreate2Address({
+    from: POLYMARKET_SAFE_FACTORY_ADDRESS,
+    salt,
+    bytecodeHash: POLYMARKET_SAFE_INIT_CODE_HASH
+  });
+}
+function isPolymarketAsset(asset) {
+  return asset.source === "polymarket";
+}
+async function fetchPolymarketBalances(params) {
+  const safeAddress = derivePolymarketSafeAddress(params.owner);
+  const balances = await Promise.all([
+    readTokenBalance(params.publicClient, POLYMARKET_USDCE_ADDRESS, safeAddress),
+    readTokenBalance(params.publicClient, POLYMARKET_PUSD_ADDRESS, safeAddress)
+  ]);
+  const [usdceBalance, pusdBalance] = balances;
+  const assets = [];
+  if (usdceBalance > 0n) {
+    assets.push(
+      buildPolymarketAsset({
+        kind: "usdce",
+        safeAddress,
+        balance: usdceBalance
+      })
+    );
+  }
+  if (pusdBalance > 0n) {
+    assets.push(
+      buildPolymarketAsset({
+        kind: "pusd",
+        safeAddress,
+        balance: pusdBalance
+      })
+    );
+  }
+  return {
+    safeAddress,
+    assets,
+    totalUsd: assets.reduce((sum, asset) => sum + (asset.balanceUsd ?? 0), 0)
+  };
+}
+async function executePolymarketSafeTransfer(params) {
+  const account = params.walletClient.account;
+  const chain = params.walletClient.chain;
+  if (!account || !chain) {
+    throw new Error("Wallet not connected");
+  }
+  if (chain.id !== POLYMARKET_POLYGON_CHAIN_ID) {
+    throw new Error("Switch to Polygon to sign");
+  }
+  const isOwner = await params.publicClient.readContract({
+    address: params.safeAddress,
+    abi: SAFE_ABI,
+    functionName: "isOwner",
+    args: [account.address]
+  });
+  if (!isOwner) {
+    throw new Error("Connected wallet is not a Polymarket Safe owner");
+  }
+  const safeTx = params.tokenKind === "pusd" ? buildPusdUnwrapSafeTx(params.recipient, params.amount) : buildUsdceTransferSafeTx(params.recipient, params.amount);
+  const signature = concat([
+    pad(account.address, { size: 32 }),
+    pad(toHex(0), { size: 32 }),
+    toHex(1, { size: 1 })
+  ]);
+  const txHash = await params.walletClient.writeContract({
+    account,
+    chain,
+    address: params.safeAddress,
+    abi: SAFE_ABI,
+    functionName: "execTransaction",
+    args: [
+      safeTx.to,
+      0n,
+      safeTx.data,
+      safeTx.operation,
+      0n,
+      0n,
+      0n,
+      zeroAddress,
+      zeroAddress,
+      signature
+    ]
+  });
+  const receipt = await params.publicClient.waitForTransactionReceipt({
+    hash: txHash
+  });
+  const parsed = parseEventLogs({
+    abi: SAFE_ABI,
+    logs: receipt.logs.filter(
+      (log) => log.address.toLowerCase() === params.safeAddress.toLowerCase()
+    ),
+    strict: false
+  });
+  if (parsed.some((log) => log.eventName === "ExecutionFailure")) {
+    throw new Error("Polymarket Safe transaction failed");
+  }
+  if (!parsed.some((log) => log.eventName === "ExecutionSuccess")) {
+    throw new Error("Polymarket Safe transaction status unavailable");
+  }
+  return {
+    txHash,
+    sourceToken: POLYMARKET_USDCE_ADDRESS,
+    sourceSymbol: params.tokenKind === "pusd" ? "pUSD" : "USDC.e"
+  };
+}
+function buildPolymarketAsset(params) {
+  const isPusd = params.kind === "pusd";
+  const symbol = isPusd ? "pUSD" : "USDC.e";
+  const balanceUsd = Number(formatUnits(params.balance, 6));
+  return {
+    id: `polymarket:${params.kind}`,
+    chainId: POLYMARKET_POLYGON_CHAIN_ID,
+    token: isPusd ? POLYMARKET_PUSD_ADDRESS : POLYMARKET_USDCE_ADDRESS,
+    symbol,
+    name: isPusd ? "Polymarket USD" : "Polygon USDC.e",
+    decimals: 6,
+    balance: params.balance.toString(),
+    balanceUsd: Number.isFinite(balanceUsd) ? balanceUsd : 0,
+    source: "polymarket",
+    sourceLabel: "Polymarket",
+    balanceAddress: params.safeAddress,
+    depositToken: POLYMARKET_USDCE_ADDRESS,
+    polymarketTokenKind: params.kind,
+    polymarketSafeAddress: params.safeAddress,
+    reviewLabel: isPusd ? "You send pUSD from Polymarket" : "You send USDC.e from Polymarket"
+  };
+}
+async function readTokenBalance(publicClient, token, holder) {
+  try {
+    return await publicClient.readContract({
+      address: token,
+      abi: erc20Abi,
+      functionName: "balanceOf",
+      args: [holder]
+    });
+  } catch {
+    return 0n;
+  }
+}
+function buildUsdceTransferSafeTx(recipient, amount) {
+  return {
+    to: POLYMARKET_USDCE_ADDRESS,
+    data: encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "transfer",
+      args: [recipient, amount]
+    }),
+    operation: 0
+  };
+}
+function buildPusdUnwrapSafeTx(recipient, amount) {
+  const approveData = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "approve",
+    args: [POLYMARKET_COLLATERAL_OFFRAMP_ADDRESS, amount]
+  });
+  const unwrapData = encodeFunctionData({
+    abi: COLLATERAL_OFFRAMP_ABI,
+    functionName: "unwrap",
+    args: [POLYMARKET_USDCE_ADDRESS, recipient, amount]
+  });
+  return {
+    to: SAFE_MULTI_SEND_CALL_ONLY_ADDRESS,
+    data: encodeFunctionData({
+      abi: MULTI_SEND_ABI,
+      functionName: "multiSend",
+      args: [
+        concat([
+          encodeMultiSendCall(POLYMARKET_PUSD_ADDRESS, approveData),
+          encodeMultiSendCall(POLYMARKET_COLLATERAL_OFFRAMP_ADDRESS, unwrapData)
+        ])
+      ]
+    }),
+    operation: 1
+  };
+}
+function encodeMultiSendCall(to, data) {
+  return encodePacked(
+    ["uint8", "address", "uint256", "uint256", "bytes"],
+    [0, to, 0n, BigInt((data.length - 2) / 2), data]
+  );
+}
+
+export {
+  POLYMARKET_POLYGON_CHAIN_ID,
+  POLYMARKET_SAFE_FACTORY_ADDRESS,
+  POLYMARKET_SAFE_INIT_CODE_HASH,
+  POLYMARKET_USDCE_ADDRESS,
+  POLYMARKET_PUSD_ADDRESS,
+  POLYMARKET_COLLATERAL_OFFRAMP_ADDRESS,
+  SAFE_MULTI_SEND_CALL_ONLY_ADDRESS,
+  derivePolymarketSafeAddress,
+  isPolymarketAsset,
+  fetchPolymarketBalances,
+  executePolymarketSafeTransfer
+};