@pafi-dev/core 0.3.0-beta.1 → 0.3.0-beta.11

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   pointTokenFactoryAbi
-} from "./chunk-5YH4D7QF.js";
+} from "./chunk-7UBO7DY5.js";
 import {
   createLoginMessage,
   parseLoginMessage,
@@ -14,25 +14,27 @@ import {
   getPointTokenIssuer,
   getReceiverConsentNonce,
   getTokenName,
-  getUsdt,
   isActiveIssuer,
   isMinter,
   verifyMintCap
-} from "./chunk-VQSRCMMK.js";
+} from "./chunk-QGO6X6LG.js";
 import {
   issuerRegistryAbi,
   mintingOracleAbi,
   pointTokenAbi
 } from "./chunk-FXNG4G22.js";
 import {
+  buildBurnRequestTypedData,
   buildDomain,
   buildMintRequestTypedData,
   buildReceiverConsentTypedData,
+  signBurnRequest,
   signMintRequest,
   signReceiverConsent,
+  verifyBurnRequest,
   verifyMintRequest,
   verifyReceiverConsent
-} from "./chunk-C4ZDYG4D.js";
+} from "./chunk-DUY7Z2AI.js";
 import {
   buildAllPaths,
   combineRoutes,
@@ -40,7 +42,7 @@ import {
   quoteBestRoute,
   quoteExactInput,
   quoteExactInputSingle
-} from "./chunk-FIKTQR7H.js";
+} from "./chunk-I2P3TIP7.js";
 import {
   v4QuoterAbi
 } from "./chunk-KFWZRL7I.js";
@@ -51,24 +53,19 @@ import {
   SUPPORTED_CHAINS,
   UNIVERSAL_ROUTER_ADDRESSES,
   V4_QUOTER_ADDRESSES,
+  burnRequestTypes,
   mintRequestTypes,
   receiverConsentTypes
-} from "./chunk-R4L66ZR5.js";
-import {
-  buildRelaySwapParams,
-  decodeExtData,
-  decodeMintAndSwap,
-  encodeExtData,
-  encodeMintAndSwap,
-  simulateMintAndSwap
-} from "./chunk-X4IXUTTD.js";
-import {
-  relayAbi
-} from "./chunk-4RYBJLF3.js";
+} from "./chunk-73CQTNLB.js";
 import {
+  ApiError,
   BATCH_EXECUTOR_ABI,
+  ConfigurationError,
+  PafiSDKError,
   SETTLE_ALL,
   SWAP_EXACT_IN,
+  SigningError,
+  SimulationError,
   TAKE_ALL,
   V4_SWAP,
   assembleUserOperation,
@@ -86,23 +83,156 @@ import {
   erc20TransferOp,
   rawCallOp,
   simulateSwap
-} from "./chunk-IK4UK7KT.js";
+} from "./chunk-W23EJNYG.js";
 import {
   erc20Abi,
   permit2Abi,
   universalRouterAbi
 } from "./chunk-2PIXFXA2.js";
-import {
-  ApiError,
-  ConfigurationError,
-  PafiSDKError,
-  SigningError,
-  SimulationError
-} from "./chunk-P56TUGTS.js";
 
 // src/index.ts
 import { createPublicClient, http } from "viem";
 
+// src/perp/buildPerpDepositWithGasDeduction.ts
+import { encodeFunctionData } from "viem";
+
+// src/contracts/real/orderlyVault.ts
+import { keccak256, encodePacked, encodeAbiParameters } from "viem";
+var ORDERLY_VAULT_BASE_MAINNET = "0xDe5cE5DD048596e46Ff671b13317aCC3C5B59b01";
+var ORDERLY_VAULT_ADDRESSES = {
+  8453: ORDERLY_VAULT_BASE_MAINNET
+};
+var BROKER_HASHES = {
+  /** Default partner broker on Base — most commonly whitelisted. */
+  woofi_pro: keccak256(encodePacked(["string"], ["woofi_pro"])),
+  /** Orderly's own white-label broker. */
+  orderly: keccak256(encodePacked(["string"], ["orderly"])),
+  /** LogX. */
+  logx: keccak256(encodePacked(["string"], ["logx"]))
+};
+var TOKEN_HASHES = {
+  USDC: keccak256(encodePacked(["string"], ["USDC"]))
+};
+function computeAccountId(user, brokerHash) {
+  return keccak256(
+    encodeAbiParameters(
+      [
+        { type: "address" },
+        { type: "bytes32" }
+      ],
+      [user, brokerHash]
+    )
+  );
+}
+var ORDERLY_VAULT_ABI = [
+  // Deposit USDC into Orderly perp account. Emits LayerZero message
+  // to the Orderly chain. `msg.value` MUST equal `getDepositFee(...)`.
+  {
+    type: "function",
+    name: "deposit",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "data",
+        type: "tuple",
+        components: [
+          { name: "accountId", type: "bytes32" },
+          { name: "brokerHash", type: "bytes32" },
+          { name: "tokenHash", type: "bytes32" },
+          { name: "tokenAmount", type: "uint128" }
+        ]
+      }
+    ],
+    outputs: []
+  },
+  // Quote the LayerZero fee for a deposit message. Pass the same
+  // VaultDepositFE struct you intend to send.
+  {
+    type: "function",
+    name: "getDepositFee",
+    stateMutability: "view",
+    inputs: [
+      { name: "user", type: "address" },
+      {
+        name: "data",
+        type: "tuple",
+        components: [
+          { name: "accountId", type: "bytes32" },
+          { name: "brokerHash", type: "bytes32" },
+          { name: "tokenHash", type: "bytes32" },
+          { name: "tokenAmount", type: "uint128" }
+        ]
+      }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  // Pre-flight check — is this brokerId whitelisted on this Vault?
+  {
+    type: "function",
+    name: "getAllowedBroker",
+    stateMutability: "view",
+    inputs: [{ name: "brokerHash", type: "bytes32" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  // Pre-flight check — what ERC-20 address does this token symbol
+  // resolve to on this Vault?
+  {
+    type: "function",
+    name: "getAllowedToken",
+    stateMutability: "view",
+    inputs: [{ name: "tokenHash", type: "bytes32" }],
+    outputs: [{ name: "", type: "address" }]
+  }
+];
+
+// src/perp/buildPerpDepositWithGasDeduction.ts
+function buildPerpDepositWithGasDeduction(params) {
+  if (params.amount <= 0n) {
+    throw new Error("buildPerpDepositWithGasDeduction: amount must be positive");
+  }
+  if (params.layerZeroFee < 0n) {
+    throw new Error(
+      "buildPerpDepositWithGasDeduction: layerZeroFee cannot be negative"
+    );
+  }
+  if (params.depositData.tokenAmount !== params.amount) {
+    throw new Error(
+      `buildPerpDepositWithGasDeduction: depositData.tokenAmount (${params.depositData.tokenAmount}) must equal amount (${params.amount})`
+    );
+  }
+  const vault = params.vaultAddress ?? ORDERLY_VAULT_ADDRESSES[params.chainId];
+  if (!vault) {
+    throw new Error(
+      `buildPerpDepositWithGasDeduction: no Orderly Vault address for chainId ${params.chainId}`
+    );
+  }
+  const depositCallData = encodeFunctionData({
+    abi: ORDERLY_VAULT_ABI,
+    functionName: "deposit",
+    args: [params.depositData]
+  });
+  const operations = [
+    erc20ApproveOp(params.usdcAddress, vault, params.amount),
+    {
+      ...rawCallOp(vault, depositCallData),
+      // BatchExecutor passes `value` from the inner call along; this
+      // becomes the LayerZero fee. The aggregated `msg.value` for the
+      // top-level UserOp must equal the sum of inner `value`s.
+      value: params.layerZeroFee
+    }
+  ];
+  return buildPartialUserOperation({
+    sender: params.userAddress,
+    nonce: params.aaNonce,
+    operations,
+    gasLimits: {
+      callGasLimit: params.gasLimits?.callGasLimit ?? 800000n,
+      verificationGasLimit: params.gasLimits?.verificationGasLimit ?? 150000n,
+      preVerificationGas: params.gasLimits?.preVerificationGas ?? 50000n
+    }
+  });
+}
+
 // src/userop/types.ts
 var ENTRY_POINT_V07 = "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
 var ZERO_VALUE = 0n;
@@ -150,186 +280,300 @@ async function checkEthAndBranch(params) {
   return balance >= required ? "normal" : "paymaster";
 }
 
-// src/contracts/mocks/relayerV2.mock.ts
-import { parseAbi } from "viem";
-var MOCK_RELAYER_V2_ABI = parseAbi([
-  "function mint((address to, uint256 amount, uint256 feeAmount, address feeRecipient, uint256 nonce, uint256 deadline, bytes extData) request, (uint8 v, bytes32 r, bytes32 s) userSig, (uint8 v, bytes32 r, bytes32 s) issuerSig) external",
-  // View functions we'll likely want (nonce getter is standard)
-  "function mintRequestNonce(address user) external view returns (uint256)",
-  "event Minted(address indexed user, uint256 amount, uint256 feeAmount, address indexed feeRecipient, bytes32 requestHash)"
-]);
-var MOCK_RELAYER_V2_MINT_SELECTOR = "0xMOCKED__";
+// src/delegation/checkDelegation.ts
+var EIP7702_MAGIC = "0xef0100";
+function parseEip7702DelegatedAddress(code) {
+  if (!code || code === "0x" || code === "0x0") return null;
+  const normalized = code.toLowerCase();
+  const magic = EIP7702_MAGIC.toLowerCase();
+  const idx = normalized.indexOf(magic);
+  if (idx === -1) return null;
+  const raw = normalized.slice(idx + magic.length, idx + magic.length + 40);
+  if (raw.length !== 40) return null;
+  return `0x${raw}`;
+}
+async function checkDelegation(client, address) {
+  const code = await client.getCode({ address });
+  return parseEip7702DelegatedAddress(code);
+}
+async function isDelegatedTo(client, address, target) {
+  const impl = await checkDelegation(client, address);
+  if (!impl) return false;
+  return impl.toLowerCase() === target.toLowerCase();
+}
 
-// src/contracts/mocks/pointTokenV2.mock.ts
-import { parseAbi as parseAbi2 } from "viem";
-var MOCK_POINT_TOKEN_V2_ABI = parseAbi2([
-  // Variant A
-  "function burn(uint256 amount) external",
-  // Variant B
-  "function burnWithSig((address user, address pointToken, uint256 amount, uint256 nonce, uint256 deadline) consent, (uint8 v, bytes32 r, bytes32 s) sig) external",
-  // Standard reads we always need
-  "function balanceOf(address user) external view returns (uint256)",
-  "function burnNonce(address user) external view returns (uint256)",
-  // ERC-20 Transfer event (inherited) — BurnIndexer filters `to = 0x0`
-  "event Transfer(address indexed from, address indexed to, uint256 value)"
+// src/delegation/buildDelegationUserOp.ts
+function buildDelegationUserOp(params) {
+  return buildPartialUserOperation({
+    sender: params.userAddress,
+    nonce: params.aaNonce,
+    operations: [
+      {
+        // Self-call with no data — triggers EIP-7702 delegation without
+        // executing any inner logic. The BatchExecutor.execute([]) call with
+        // an empty array would revert, so we target the EOA itself (which
+        // forwards to BatchExecutor that then no-ops on empty input).
+        target: params.userAddress,
+        value: 0n,
+        data: "0x"
+      }
+    ],
+    gasLimits: {
+      callGasLimit: params.gasLimits?.callGasLimit ?? 50000n,
+      verificationGasLimit: params.gasLimits?.verificationGasLimit ?? 150000n,
+      preVerificationGas: params.gasLimits?.preVerificationGas ?? 50000n
+    }
+  });
+}
+async function getAaNonce(client, userAddress) {
+  const ENTRY_POINT = "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
+  const NONCE_ABI = [
+    {
+      inputs: [
+        { name: "sender", type: "address" },
+        { name: "key", type: "uint192" }
+      ],
+      name: "getNonce",
+      outputs: [{ name: "nonce", type: "uint256" }],
+      stateMutability: "view",
+      type: "function"
+    }
+  ];
+  return client.readContract({
+    address: ENTRY_POINT,
+    abi: NONCE_ABI,
+    functionName: "getNonce",
+    args: [userAddress, 0n]
+  });
+}
+
+// src/contracts/real/pointToken.ts
+import { parseAbi } from "viem";
+var POINT_TOKEN_ABI = parseAbi([
+  // --- Mint paths ---
+  "function mint(address to, uint256 amount) external",
+  "function mint(address to, uint256 amount, uint256 deadline, bytes minterSig) external",
+  // --- Burn paths ---
+  "function burn(address from, uint256 amount) external",
+  "function burn(address from, uint256 amount, uint256 deadline, bytes burnerSig) external",
+  // --- Authorization reads ---
+  "function minters(address account) external view returns (bool)",
+  "function burners(address account) external view returns (bool)",
+  // --- Authorization writes (owner-only; used by provisioning scripts) ---
+  "function addMinter(address minter) external",
+  "function removeMinter(address minter) external",
+  "function addBurner(address burner) external",
+  "function removeBurner(address burner) external",
+  // --- Nonces (sig-gated paths) ---
+  "function mintRequestNonces(address receiver) external view returns (uint256)",
+  "function burnRequestNonces(address from) external view returns (uint256)",
+  // --- Oracle ---
+  "function mintingOracle() external view returns (address)",
+  "function setMintingOracle(address _mintingOracle) external",
+  // --- Issuer ---
+  "function issuer() external view returns (address)",
+  // --- Standard ERC-20 reads ---
+  "function balanceOf(address account) external view returns (uint256)",
+  "function totalSupply() external view returns (uint256)",
+  "function name() external view returns (string)",
+  "function symbol() external view returns (string)",
+  "function decimals() external view returns (uint8)",
+  // --- EIP-712 domain (for off-chain sig verification) ---
+  "function DOMAIN_SEPARATOR() external view returns (bytes32)",
+  "function eip712Domain() external view returns (bytes1 fields, string name, string version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] extensions)",
+  // --- Events ---
+  // PointIndexer filters Transfer(from=0x0) for mints
+  // BurnIndexer filters Transfer(to=0x0) for burns
+  "event Transfer(address indexed from, address indexed to, uint256 value)",
+  "event MinterAdded(address indexed minter)",
+  "event MinterRemoved(address indexed minter)",
+  "event BurnerAdded(address indexed burner)",
+  "event BurnerRemoved(address indexed burner)",
+  "event MintingOracleUpdated(address indexed mintingOracle)"
 ]);
 
-// src/contracts/mocks/batchExecutor.mock.ts
-var MOCK_BATCH_EXECUTOR_ADDRESS_BASE_SEPOLIA = "0x000000000000000000000000000000000000DE01";
-var MOCK_BATCH_EXECUTOR_ADDRESS_BASE_MAINNET = "0x000000000000000000000000000000000000DE02";
+// src/contracts/real/batchExecutor.ts
+var BATCH_EXECUTOR_ADDRESS_BASE_SEPOLIA = "0x000000000000000000000000000000000000DE01";
+var BATCH_EXECUTOR_ADDRESS_BASE_MAINNET = "0x7702cb554e6bFb442cb743A7dF23154544a7176C";
 
-// src/contracts/mocks/addresses.mock.ts
-var MOCK_PLACEHOLDER = (suffix) => `0x000000000000000000000000000000000000${suffix.toLowerCase().padStart(4, "0")}`;
-var MOCK_ADDRESSES = {
-  // Base Sepolia — safe targets for integration tests (MockRelayer
-  // fixtures deployed by Hardhat will override these at test time)
-  84532: {
-    relayerV2: MOCK_PLACEHOLDER("de10"),
-    pointToken: MOCK_PLACEHOLDER("de11"),
-    batchExecutor: MOCK_PLACEHOLDER("de01"),
-    usdt: MOCK_PLACEHOLDER("de12"),
-    issuerRegistry: MOCK_PLACEHOLDER("de13"),
-    mintingOracle: MOCK_PLACEHOLDER("de14")
-  },
-  // Base mainnet — intentionally left as placeholder. Do NOT ship to
-  // prod without swapping.
+// src/contracts/real/addresses.ts
+var PLACEHOLDER_DEAD = (suffix) => `0x000000000000000000000000000000000000${suffix.toLowerCase().padStart(4, "0")}`;
+var CONTRACT_ADDRESSES = {
+  // Base mainnet — SC-delivered (2026-04-21, 2026-04-22)
+  // registry:       IssuerRegistry       0xda2D3338CF70F462Ac175F5f2edfa45660CA4f31
+  // factory:        PointTokenFactory    0x36c0BAb2faBE45EfA6d13001143e43A266Af673B
+  // oracle:         MintingOracle        0xD85165939C700E51c8a45099316C6482634C2Ab9
+  // tokenImpl:      PointToken (impl)    0x2e6FB1B0C1A51abb83eC974890126a64eC02E995
+  // mockUsdt:       MockERC20            0x5d313485Ba59C3bb91e1A9C0C11782F0b83d5dcd
+  // POINT:          PointToken instance  0x7d25E7156E51F865D522fd3ef257a6B5DD41b97e
+  // batchExecutor:  Coinbase SW v2       0x7702cb554e6bFb442cb743A7dF23154544a7176C
+  // pafiHook:       PAFIHook (V4, 10%)   0x870cAF9882d3160602AaC1769C2B264A2d8EC044
   8453: {
-    relayerV2: MOCK_PLACEHOLDER("dead"),
-    pointToken: MOCK_PLACEHOLDER("dead"),
-    batchExecutor: MOCK_PLACEHOLDER("dead"),
-    usdt: MOCK_PLACEHOLDER("dead"),
-    issuerRegistry: MOCK_PLACEHOLDER("dead"),
-    mintingOracle: MOCK_PLACEHOLDER("dead")
+    pointToken: "0x7d25E7156E51F865D522fd3ef257a6B5DD41b97e",
+    batchExecutor: "0x7702cb554e6bFb442cb743A7dF23154544a7176C",
+    usdt: "0x5d313485Ba59C3bb91e1A9C0C11782F0b83d5dcd",
+    issuerRegistry: "0xda2D3338CF70F462Ac175F5f2edfa45660CA4f31",
+    mintingOracle: "0xD85165939C700E51c8a45099316C6482634C2Ab9",
+    pafiHook: "0x870cAF9882d3160602AaC1769C2B264A2d8EC044"
+  },
+  // Base Sepolia — not in active use; placeholders kept so the map
+  // compiles for tooling that enumerates chains.
+  84532: {
+    pointToken: PLACEHOLDER_DEAD("dead"),
+    batchExecutor: PLACEHOLDER_DEAD("de01"),
+    usdt: PLACEHOLDER_DEAD("dead"),
+    issuerRegistry: PLACEHOLDER_DEAD("dead"),
+    mintingOracle: PLACEHOLDER_DEAD("dead"),
+    pafiHook: PLACEHOLDER_DEAD("dead")
   }
 };
-function getMockAddresses(chainId) {
-  const addrs = MOCK_ADDRESSES[chainId];
+var POINT_TOKEN_FACTORY_ADDRESSES = {
+  8453: "0x36c0BAb2faBE45EfA6d13001143e43A266Af673B",
+  84532: PLACEHOLDER_DEAD("dead")
+};
+var POINT_TOKEN_IMPL_ADDRESSES = {
+  8453: "0x2e6FB1B0C1A51abb83eC974890126a64eC02E995",
+  84532: PLACEHOLDER_DEAD("dead")
+};
+function getContractAddresses(chainId) {
+  const addrs = CONTRACT_ADDRESSES[chainId];
   if (!addrs) {
     throw new Error(
-      `getMockAddresses: no mock addresses for chainId ${chainId}. Supported: ${Object.keys(MOCK_ADDRESSES).join(", ")}`
+      `getContractAddresses: no addresses for chainId ${chainId}. Supported: ${Object.keys(CONTRACT_ADDRESSES).join(", ")}`
     );
   }
   return addrs;
 }
 
-// src/contracts/mocks/eip712/mintRequestV2.mock.ts
-import {
-  parseSignature,
-  recoverTypedDataAddress
-} from "viem";
-var MOCK_MINT_REQUEST_V2_TYPES = {
-  MintRequest: [
-    { name: "to", type: "address" },
-    { name: "amount", type: "uint256" },
-    { name: "feeAmount", type: "uint256" },
-    { name: "feeRecipient", type: "address" },
-    { name: "nonce", type: "uint256" },
-    { name: "deadline", type: "uint256" },
-    { name: "extData", type: "bytes" }
-  ]
-};
-function buildMockMintRequestV2TypedData(domain, message) {
-  return {
-    domain: buildDomain(domain),
-    types: MOCK_MINT_REQUEST_V2_TYPES,
-    primaryType: "MintRequest",
-    message
-  };
-}
-async function signMockMintRequestV2(walletClient, domain, message) {
-  const serialized = await walletClient.signTypedData({
-    account: walletClient.account,
-    domain: buildDomain(domain),
-    types: MOCK_MINT_REQUEST_V2_TYPES,
-    primaryType: "MintRequest",
-    message
-  });
-  const { v, r, s } = parseSignature(serialized);
-  return {
-    v: Number(v),
-    r,
-    s,
-    serialized
+// src/web-handoff/webPopup.ts
+var DEFAULT_WIDTH = 900;
+var DEFAULT_HEIGHT = 700;
+var DEFAULT_NAME = "pafi-web";
+function openWebPopup(url, options = {}) {
+  if (typeof window === "undefined" || typeof window.open !== "function") {
+    throw new Error(
+      "openWebPopup: `window.open` is not available in this runtime. Register a platform adapter via setPafiWebModalAdapter() instead."
+    );
+  }
+  const width = options.width ?? DEFAULT_WIDTH;
+  const height = options.height ?? DEFAULT_HEIGHT;
+  const name = options.windowName ?? DEFAULT_NAME;
+  const screenW = window.screen?.availWidth ?? window.innerWidth;
+  const screenH = window.screen?.availHeight ?? window.innerHeight;
+  const left = Math.max(0, Math.floor((screenW - width) / 2));
+  const top = Math.max(0, Math.floor((screenH - height) / 2));
+  const features = [
+    `width=${width}`,
+    `height=${height}`,
+    `left=${left}`,
+    `top=${top}`,
+    "resizable=yes",
+    "scrollbars=yes",
+    "noopener=no"
+    // we need opener.postMessage to work
+  ].join(",");
+  const popup = window.open(url, name, features);
+  if (!popup) {
+    throw new Error(
+      "openWebPopup: popup was blocked. Ensure this call runs inside a user gesture (click handler)."
+    );
+  }
+  let closed = false;
+  let pollId = null;
+  let messageListener = null;
+  const dispose = () => {
+    if (closed) return;
+    closed = true;
+    if (pollId !== null) {
+      clearInterval(pollId);
+      pollId = null;
+    }
+    if (messageListener) {
+      window.removeEventListener("message", messageListener);
+      messageListener = null;
+    }
+    options.onClose?.();
   };
-}
-async function verifyMockMintRequestV2(domain, message, signature, expectedSigner) {
-  const recoveredAddress = await recoverTypedDataAddress({
-    domain: buildDomain(domain),
-    types: MOCK_MINT_REQUEST_V2_TYPES,
-    primaryType: "MintRequest",
-    message,
-    signature
-  });
-  const isValid = recoveredAddress.toLowerCase() === expectedSigner.toLowerCase();
+  pollId = setInterval(() => {
+    if (popup.closed) {
+      dispose();
+    }
+  }, 500);
+  if (options.onMessage) {
+    const allowed = options.allowedOrigins ?? [];
+    const onMessage = options.onMessage;
+    messageListener = (event) => {
+      if (event.source !== popup) return;
+      if (!allowed.includes(event.origin)) return;
+      onMessage(event.data, event.origin);
+    };
+    window.addEventListener("message", messageListener);
+  }
   return {
-    isValid,
-    recoveredAddress
+    get isOpen() {
+      return !closed && !popup.closed;
+    },
+    close() {
+      if (closed) return;
+      try {
+        popup.close();
+      } catch {
+      }
+      dispose();
+    },
+    focus() {
+      if (closed || popup.closed) return;
+      try {
+        popup.focus();
+      } catch {
+      }
+    },
+    postMessage(data) {
+      if (closed || popup.closed) return;
+      try {
+        popup.postMessage(data, "*");
+      } catch {
+      }
+    }
   };
 }
-
-// src/contracts/mocks/eip712/burnConsent.mock.ts
-import {
-  parseSignature as parseSignature2,
-  recoverTypedDataAddress as recoverTypedDataAddress2
-} from "viem";
-var MOCK_BURN_CONSENT_TYPES = {
-  BurnConsent: [
-    { name: "user", type: "address" },
-    { name: "pointToken", type: "address" },
-    { name: "amount", type: "uint256" },
-    { name: "nonce", type: "uint256" },
-    { name: "deadline", type: "uint256" }
-  ]
+var webPopupAdapter = {
+  open(url, options) {
+    return openWebPopup(url, options);
+  }
 };
-function buildMockBurnConsentTypedData(domain, message) {
-  return {
-    domain: buildDomain(domain),
-    types: MOCK_BURN_CONSENT_TYPES,
-    primaryType: "BurnConsent",
-    message
-  };
+
+// src/web-handoff/index.ts
+var registeredAdapter = null;
+function setPafiWebModalAdapter(adapter) {
+  registeredAdapter = adapter;
 }
-async function signMockBurnConsent(walletClient, domain, message) {
-  const serialized = await walletClient.signTypedData({
-    account: walletClient.account,
-    domain: buildDomain(domain),
-    types: MOCK_BURN_CONSENT_TYPES,
-    primaryType: "BurnConsent",
-    message
-  });
-  const { v, r, s } = parseSignature2(serialized);
-  return {
-    v: Number(v),
-    r,
-    s,
-    serialized
-  };
+function getPafiWebModalAdapter() {
+  return registeredAdapter;
 }
-async function verifyMockBurnConsent(domain, message, signature, expectedUser) {
-  const recoveredAddress = await recoverTypedDataAddress2({
-    domain: buildDomain(domain),
-    types: MOCK_BURN_CONSENT_TYPES,
-    primaryType: "BurnConsent",
-    message,
-    signature
-  });
-  const isValid = recoveredAddress.toLowerCase() === expectedUser.toLowerCase();
-  return {
-    isValid,
-    recoveredAddress
-  };
+async function openPafiWebModal(url, options = {}) {
+  if (!url || typeof url !== "string") {
+    throw new Error("openPafiWebModal: `url` is required");
+  }
+  if (registeredAdapter) {
+    return Promise.resolve(registeredAdapter.open(url, options));
+  }
+  if (typeof window !== "undefined" && typeof window.open === "function") {
+    return openWebPopup(url, options);
+  }
+  throw new Error(
+    "openPafiWebModal: no adapter registered and `window.open` is unavailable. Call `setPafiWebModalAdapter()` with a platform-specific adapter (e.g. SFSafariViewController on iOS) during app boot."
+  );
 }
 
 // src/index.ts
 var PafiSDK = class {
   _pointTokenAddress;
-  _relayContractAddress;
   _signer;
   _provider;
   _chainId;
   constructor(config) {
     this._pointTokenAddress = config.pointTokenAddress;
-    this._relayContractAddress = config.relayContractAddress;
     this._signer = config.signer;
     this._chainId = config.chainId;
     if (config.provider) {
@@ -346,9 +590,6 @@ var PafiSDK = class {
   setPointTokenAddress(address) {
     this._pointTokenAddress = address;
   }
-  setRelayContractAddress(address) {
-    this._relayContractAddress = address;
-  }
   setSigner(signer) {
     this._signer = signer;
   }
@@ -395,18 +636,10 @@ var PafiSDK = class {
   // -------------------------------------------------------------------------
   // EIP-712 — delegates to pure functions
   // -------------------------------------------------------------------------
-  /**
-   * Build the EIP-712 typed data for a MintRequest.
-   * Pass the result to any external signer (Privy, WalletConnect, etc.).
-   */
   async buildMintRequestTypedData(message) {
     const domain = await this.getDomain();
     return buildMintRequestTypedData(domain, message);
   }
-  /**
-   * Build the EIP-712 typed data for a ReceiverConsent.
-   * Pass the result to any external signer (Privy, WalletConnect, etc.).
-   */
   async buildReceiverConsentTypedData(message) {
     const domain = await this.getDomain();
     return buildReceiverConsentTypedData(domain, message);
@@ -445,15 +678,6 @@ var PafiSDK = class {
     );
   }
   // -------------------------------------------------------------------------
-  // Relay calldata — delegates to pure functions
-  // -------------------------------------------------------------------------
-  encodeMintAndSwap(mint, swap) {
-    return encodeMintAndSwap(mint, swap);
-  }
-  decodeMintAndSwap(calldata) {
-    return decodeMintAndSwap(calldata);
-  }
-  // -------------------------------------------------------------------------
   // Quoting — delegates to pure functions
   // -------------------------------------------------------------------------
   /**
@@ -483,41 +707,9 @@ var PafiSDK = class {
   buildSwapFromQuote(params) {
     return buildSwapFromQuote(params);
   }
-  /**
-   * Build Relay SwapParams + extData from a quote result.
-   * Returns ready-to-use args for `Relay.mintAndSwap`.
-   */
-  buildRelaySwapParams(params) {
-    return buildRelaySwapParams(params);
-  }
-  /**
-   * Encode extData for ReceiverConsent and MintParams.
-   * extData = abi.encode(minAmountOut, feeInUsdt)
-   */
-  encodeExtData(minAmountOut, feeInUsdt) {
-    return encodeExtData(minAmountOut, feeInUsdt);
-  }
   // -------------------------------------------------------------------------
   // Simulation — dry-run via eth_call (no gas spent)
   // -------------------------------------------------------------------------
-  /**
-   * Simulate a Relay.mintAndSwap call. Catches reverts (bad signatures,
-   * expired deadlines, insufficient mint cap, pool errors) before submitting.
-   *
-   * @param relayAddress - Relay contract address
-   * @param mint         - MintParams with real signatures
-   * @param swap         - SwapParams (path + deadline)
-   * @param from         - Relayer address that will submit the tx
-   */
-  async simulateMintAndSwap(relayAddress, mint, swap, from) {
-    return simulateMintAndSwap(
-      this.requireProvider(),
-      relayAddress,
-      mint,
-      swap,
-      from
-    );
-  }
   /**
    * Simulate a UniversalRouter.execute swap call. Catches reverts (bad
    * approvals, insufficient balance, pool errors) before submitting.
@@ -540,17 +732,7 @@ var PafiSDK = class {
   }
   // -------------------------------------------------------------------------
   // Auth — EIP-4361 login helpers (offline, stateless)
-  //
-  // These are convenience wrappers around the pure functions in
-  // `./auth/loginMessage.ts`. They do NOT hit the network — the caller is
-  // responsible for fetching the nonce, POSTing the signed message, and
-  // storing the JWT returned by the issuer backend.
   // -------------------------------------------------------------------------
-  /**
-   * Build an EIP-4361 login message for the current signer + chain. The
-   * caller supplies the issuer-specific fields (domain, nonce, uri); the SDK
-   * fills in the wallet address and chain id from its own config.
-   */
   async createLoginMessage(params) {
     const signer = this.requireSigner();
     const chainId = this.requireChainId();
@@ -573,27 +755,30 @@ var PafiSDK = class {
 export {
   ApiError,
   BATCH_EXECUTOR_ABI,
-  MOCK_BATCH_EXECUTOR_ADDRESS_BASE_MAINNET as BATCH_EXECUTOR_ADDRESS_BASE_MAINNET,
-  MOCK_BATCH_EXECUTOR_ADDRESS_BASE_SEPOLIA as BATCH_EXECUTOR_ADDRESS_BASE_SEPOLIA,
-  MOCK_BURN_CONSENT_TYPES as BURN_CONSENT_TYPES,
+  BATCH_EXECUTOR_ADDRESS_BASE_MAINNET,
+  BATCH_EXECUTOR_ADDRESS_BASE_SEPOLIA,
+  BROKER_HASHES,
   COMMON_POOLS,
   COMMON_TOKENS,
-  MOCK_ADDRESSES as CONTRACT_ADDRESSES,
+  CONTRACT_ADDRESSES,
   ConfigurationError,
   ENTRY_POINT_V07,
-  MOCK_MINT_REQUEST_V2_TYPES as MINT_REQUEST_V2_TYPES,
+  ORDERLY_VAULT_ABI,
+  ORDERLY_VAULT_ADDRESSES,
+  ORDERLY_VAULT_BASE_MAINNET,
+  POINT_TOKEN_FACTORY_ADDRESSES,
+  POINT_TOKEN_IMPL_ADDRESSES,
   POINT_TOKEN_POOLS,
-  MOCK_POINT_TOKEN_V2_ABI as POINT_TOKEN_V2_ABI,
+  POINT_TOKEN_ABI as POINT_TOKEN_V2_ABI,
   PafiSDK,
   PafiSDKError,
-  MOCK_RELAYER_V2_ABI as RELAYER_V2_ABI,
-  MOCK_RELAYER_V2_MINT_SELECTOR as RELAYER_V2_MINT_SELECTOR,
   SETTLE_ALL,
   SUPPORTED_CHAINS,
   SWAP_EXACT_IN,
   SigningError,
   SimulationError,
   TAKE_ALL,
+  TOKEN_HASHES,
   UNIVERSAL_ROUTER_ADDRESSES,
   V4_QUOTER_ADDRESSES,
   V4_SWAP,
@@ -601,49 +786,53 @@ export {
   _resetPaymasterConfigForTests,
   assembleUserOperation,
   buildAllPaths,
-  buildMockBurnConsentTypedData as buildBurnConsentTypedData,
+  buildBurnRequestTypedData,
+  buildDelegationUserOp,
   buildDomain,
   buildErc20ApprovalCalldata,
   buildMintRequestTypedData,
-  buildMockMintRequestV2TypedData as buildMintRequestV2TypedData,
   buildPartialUserOperation,
   buildPermit2ApprovalCalldata,
+  buildPerpDepositWithGasDeduction,
   buildReceiverConsentTypedData,
-  buildRelaySwapParams,
   buildSwapFromQuote,
   buildSwapWithGasDeduction,
   buildUniversalRouterExecuteArgs,
   buildV4SwapInput,
+  burnRequestTypes,
   checkAllowance,
+  checkDelegation,
   checkEthAndBranch,
   combineRoutes,
+  computeAccountId,
   createLoginMessage,
-  decodeExtData,
-  decodeMintAndSwap,
   encodeBatchExecute,
-  encodeExtData,
-  encodeMintAndSwap,
   erc20Abi,
   erc20ApproveOp,
   erc20BurnOp,
   erc20TransferOp,
   findBestQuote,
-  getMockAddresses as getContractAddresses,
+  getAaNonce,
+  getContractAddresses,
   getIssuer2 as getIssuer,
   getMintRequestNonce,
+  getPafiWebModalAdapter,
   getPaymasterConfig,
   getPointTokenBalance,
   getPointTokenIssuer,
   getIssuer as getPointTokenIssuerAddress,
   getReceiverConsentNonce,
   getTokenName,
-  getUsdt,
   isActiveIssuer,
+  isDelegatedTo,
   isMinter,
   isPaymasterConfigured,
   issuerRegistryAbi,
   mintRequestTypes,
   mintingOracleAbi,
+  openPafiWebModal,
+  openWebPopup,
+  parseEip7702DelegatedAddress,
   parseLoginMessage,
   permit2Abi,
   pointTokenAbi,
@@ -653,21 +842,19 @@ export {
   quoteExactInputSingle,
   rawCallOp,
   receiverConsentTypes,
-  relayAbi,
+  setPafiWebModalAdapter,
   setPaymasterConfig,
-  signMockBurnConsent as signBurnConsent,
+  signBurnRequest,
   signMintRequest,
-  signMockMintRequestV2 as signMintRequestV2,
   signReceiverConsent,
-  simulateMintAndSwap,
   simulateSwap,
   universalRouterAbi,
   v4QuoterAbi,
-  verifyMockBurnConsent as verifyBurnConsent,
+  verifyBurnRequest,
   verifyLoginMessage,
   verifyMintCap,
   verifyMintRequest,
-  verifyMockMintRequestV2 as verifyMintRequestV2,
-  verifyReceiverConsent
+  verifyReceiverConsent,
+  webPopupAdapter
 };
 //# sourceMappingURL=index.js.map