@pafi-dev/core 0.3.0-beta.5 → 0.3.0-beta.7

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export { erc20Abi, issuerRegistryAbi, mintingOracleAbi, permit2Abi, pointTokenAb
 export { buildBurnRequestTypedData, buildDomain, buildMintRequestTypedData, buildReceiverConsentTypedData, signBurnRequest, signMintRequest, signReceiverConsent, verifyBurnRequest, verifyMintRequest, verifyReceiverConsent } from './eip712/index.js';
 export { getIssuer, getMintRequestNonce, getPointTokenBalance, getPointTokenIssuer, getPointTokenIssuerAddress, getReceiverConsentNonce, getTokenName, isActiveIssuer, isMinter, verifyMintCap } from './contract/index.js';
 export { buildAllPaths, combineRoutes, findBestQuote, quoteBestRoute, quoteExactInput, quoteExactInputSingle } from './quoting/index.js';
-import { O as Operation, P as PartialUserOperation, U as UserOperation, S as SwapSimulationResult } from './index-B06IJlHe.js';
+import { P as PartialUserOperation, O as Operation, U as UserOperation, S as SwapSimulationResult } from './index-B06IJlHe.js';
 export { B as BuildSwapWithGasDeductionParams, E as ENTRY_POINT_V07, a as PaymasterFields, b as SETTLE_ALL, c as SWAP_EXACT_IN, T as TAKE_ALL, d as UserOpReceipt, V as V4_SWAP, Z as ZERO_VALUE, e as buildErc20ApprovalCalldata, f as buildPermit2ApprovalCalldata, g as buildSwapFromQuote, h as buildSwapWithGasDeduction, i as buildUniversalRouterExecuteArgs, j as buildV4SwapInput, k as checkAllowance, s as simulateSwap } from './index-B06IJlHe.js';
 import { LoginMessageParams } from './auth/index.js';
 export { VerifyLoginResult, createLoginMessage, parseLoginMessage, verifyLoginMessage } from './auth/index.js';
@@ -87,6 +87,256 @@ declare class ApiError extends PafiSDKError {
     constructor(message: string, status?: number | undefined);
 }
 
+/**
+ * Orderly Network Vault — entrypoint for **perp deposit** flow on
+ * Base mainnet (Scenario 3).
+ *
+ * Source of truth for addresses + integration:
+ *   https://orderly.network/docs/build-on-omnichain/addresses#base
+ *
+ * ## Architecture
+ *
+ *   User wallet (Base)
+ *      │ 1. USDC.approve(vault, amount)
+ *      │ 2. vault.deposit{value: layerZeroFee}({
+ *      │      accountId, brokerHash, tokenHash, tokenAmount
+ *      │    })
+ *      ▼
+ *   OrderlyVault (Base)
+ *      │ — locks USDC, emits LayerZero message
+ *      ▼
+ *   Orderly chain (off-chain matching engine)
+ *      │ — credits the user's perp account
+ *      ▼
+ *   User can now place perp orders via Orderly REST/WS API
+ *
+ * **Important:** `value` is required and is the LayerZero cross-chain
+ * fee (paid in native ETH on Base). Quote it via
+ * `vault.getDepositFee(user, data)` BEFORE calling deposit. Fees vary
+ * with destination chain congestion.
+ *
+ * ## Sponsored vs direct
+ *
+ * Coinbase Paymaster sponsors GAS, not `msg.value`. So even on the
+ * sponsored path the user MUST hold enough native ETH on Base to cover
+ * `getDepositFee()` (typically ~0.0002 ETH at quiet times).
+ */
+/** Orderly Vault on Base mainnet (EIP-55 checksum). */
+declare const ORDERLY_VAULT_BASE_MAINNET: Address;
+/**
+ * Per-chain registry of the Orderly Vault. Add chains here as Orderly
+ * deploys them.
+ */
+declare const ORDERLY_VAULT_ADDRESSES: Record<number, Address>;
+/**
+ * Pre-computed broker hashes — `keccak256(abi.encodePacked(brokerId))`.
+ * Add new brokers as they launch.
+ *
+ * Reference: https://orderly.network/docs/build-on-omnichain/user-flows/accountId
+ */
+declare const BROKER_HASHES: {
+    /** Default partner broker on Base — most commonly whitelisted. */
+    readonly woofi_pro: `0x${string}`;
+    /** Orderly's own white-label broker. */
+    readonly orderly: `0x${string}`;
+    /** LogX. */
+    readonly logx: `0x${string}`;
+};
+/**
+ * Pre-computed token hashes — `keccak256(abi.encodePacked(tokenSymbol))`.
+ * The hash maps to the actual ERC-20 address on each chain via
+ * `vault.getAllowedToken(tokenHash)`.
+ *
+ * Note: Orderly canonicalises by symbol (USDC, not "USD Coin").
+ */
+declare const TOKEN_HASHES: {
+    readonly USDC: `0x${string}`;
+};
+/**
+ * Compute Orderly's `accountId` — uniquely identifies a user+broker
+ * tuple. Matches the off-chain formula used by the Orderly SDK so
+ * deposits + future REST API calls reference the same account.
+ *
+ *   accountId = keccak256(abi.encode(user, brokerHash))
+ *
+ * Note `abi.encode` (not `encodePacked`) — uses 32-byte left-padding.
+ */
+declare function computeAccountId(user: Address, brokerHash: Hex): Hex;
+/**
+ * Minimal Orderly Vault ABI — just the functions PAFI needs for
+ * Scenario 3 (perp deposit). Full ABI is on Orderly's docs site.
+ */
+declare const ORDERLY_VAULT_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "deposit";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly name: "data";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "accountId";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "brokerHash";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "tokenHash";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "tokenAmount";
+            readonly type: "uint128";
+        }];
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "function";
+    readonly name: "getDepositFee";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly name: "data";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "accountId";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "brokerHash";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "tokenHash";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "tokenAmount";
+            readonly type: "uint128";
+        }];
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "getAllowedBroker";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "brokerHash";
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "getAllowedToken";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "tokenHash";
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+}];
+/** Struct mirror of `IOrderlyVault.VaultDepositFE` for type-safe builders. */
+interface VaultDepositFE {
+    accountId: Hex;
+    brokerHash: Hex;
+    tokenHash: Hex;
+    /** uint128 — USDC has 6 decimals. */
+    tokenAmount: bigint;
+}
+
+/**
+ * v1.5 — Scenario 3: deposit USDC from the user's wallet into the
+ * Orderly perp Vault on Base mainnet.
+ *
+ * Builds a `PartialUserOperation` packaging the 2 inner calls:
+ *
+ *   1. `USDC.approve(orderlyVault, amount)` — let the Vault pull USDC
+ *   2. `OrderlyVault.deposit{value: layerZeroFee}(VaultDepositFE)` —
+ *      transfer USDC into the Vault + emit a LayerZero message that
+ *      credits the user's perp account on the Orderly chain
+ *
+ * ## ⚠️ Native ETH constraint
+ *
+ * Coinbase Paymaster sponsors GAS, **not `msg.value`**. The LayerZero
+ * cross-chain fee MUST come from the user's own native ETH balance on
+ * Base — even when the rest of the UserOp is sponsored.
+ *
+ * Quote the fee BEFORE calling this builder via:
+ *
+ *   const fee = await client.readContract({
+ *     address: orderlyVault,
+ *     abi: ORDERLY_VAULT_ABI,
+ *     functionName: 'getDepositFee',
+ *     args: [user, depositData],
+ *   });
+ *
+ * If `user.eth < fee`, surface this error to the FE so the user can
+ * top up before retrying — the Vault `deposit{value: 0}` call will
+ * revert otherwise.
+ *
+ * ## Why no PT/USDC fee deduction?
+ *
+ * Unlike Scenario 1/2/4 which deduct an operator fee in PT/USDC inside
+ * the batch, perp deposit doesn't append a fee transfer because:
+ *
+ *   - User is paying Orderly's LayerZero fee directly via `msg.value`
+ *   - There's no PAFI-specific operator cost on top — Orderly handles
+ *     the off-chain accounting once the LayerZero message lands
+ *
+ * If we want to charge a PAFI service fee on top later, append a
+ * `USDC.transfer(feeRecipient, fee)` op — same pattern as the swap
+ * builder.
+ */
+interface BuildPerpDepositWithGasDeductionParams {
+    /** User EOA (will be `msg.sender` via EIP-7702 delegation). */
+    userAddress: Address;
+    /** ERC-4337 account nonce — fetched from EntryPoint by the caller. */
+    aaNonce: bigint;
+    /** Chain ID for Orderly Vault address resolution. */
+    chainId: number;
+    /**
+     * Override Orderly Vault address (e.g. for fork tests). Defaults to
+     * `ORDERLY_VAULT_ADDRESSES[chainId]`.
+     */
+    vaultAddress?: Address;
+    /**
+     * USDC ERC-20 address — the actual token Orderly accepts. Caller
+     * resolves this via `vault.getAllowedToken(TOKEN_HASHES.USDC)` so we
+     * don't hardcode the wrong USDC variant (native vs bridged).
+     */
+    usdcAddress: Address;
+    /** USDC amount to deposit (uint128, 6 decimals). */
+    amount: bigint;
+    /**
+     * Pre-built `VaultDepositFE` struct — caller computes accountId via
+     * `computeAccountId(user, brokerHash)` and supplies tokenHash.
+     */
+    depositData: VaultDepositFE;
+    /**
+     * LayerZero fee in wei — from `vault.getDepositFee(user, data)`.
+     * Becomes the `msg.value` on the `deposit()` call. User MUST hold
+     * ≥ this much native ETH or the call reverts.
+     */
+    layerZeroFee: bigint;
+    gasLimits?: {
+        callGasLimit?: bigint;
+        verificationGasLimit?: bigint;
+        preVerificationGas?: bigint;
+    };
+}
+/**
+ * Build an unsigned UserOp for Scenario 3. Returns a
+ * `PartialUserOperation` — caller attaches paymaster sponsorship for
+ * gas + the user's UserOp-hash signature, then submits to the Bundler.
+ */
+declare function buildPerpDepositWithGasDeduction(params: BuildPerpDepositWithGasDeductionParams): PartialUserOperation;
+
 /**
  * Build an ERC-20 `transfer(to, amount)` operation. Used inside a batch
  * to move fee tokens from the user to the fee recipient atomically with
@@ -631,21 +881,18 @@ declare const POINT_TOKEN_ABI: readonly [{
  *
  * ## Status
  *
- * Per-chain addresses are **still placeholder** (`0x...DE01` / `DE02`)
- * pending the SC team's Phase B delivery. When Coinbase publishes a
- * canonical BatchExecutor, or PAFI deploys its own and publishes the
- * address, swap the constants below — callers already import from here
- * so no wiring changes.
+ * Base mainnet: points at **Coinbase Smart Wallet v2**
+ * (`0x7702cb554e6bFb442cb743A7dF23154544a7176C`). Coinbase publishes
+ * this as the canonical EIP-7702 delegation target on Base — every
+ * user that wants gas sponsorship via Coinbase Paymaster delegates to
+ * this single contract. One contract, all issuers.
  *
- * The ABI (`execute(Call[])`) itself is real and stable — it lives
- * under `../../userop/batchExecute.ts` and is re-exported below so
- * consumers can grab both ABI + address from one import path.
+ * Base Sepolia: placeholder; Sepolia is not in active use for PAFI.
  *
- * ## Why checksum with DEAD0001 / DEAD0002 suffix
- *
- * The placeholder pattern makes the fact-of-mockness obvious in logs
- * and block explorers. A request targeting `0x...DE01` is impossible
- * to confuse with a production contract.
+ * The ABI (`execute(Call[])`) is exported from
+ * `../../userop/batchExecute.ts` and works against the Coinbase
+ * contract without change — Coinbase Smart Wallet v2 implements the
+ * same call-array signature we already use.
  */
 declare const BATCH_EXECUTOR_ADDRESS_BASE_SEPOLIA: Address;
 declare const BATCH_EXECUTOR_ADDRESS_BASE_MAINNET: Address;
@@ -653,30 +900,28 @@ declare const BATCH_EXECUTOR_ADDRESS_BASE_MAINNET: Address;
 /**
  * Per-chain deployed contract addresses — v1.4 flow.
  *
- * ## Status (2026-04-21)
+ * ## Status (2026-04-22)
+ *
+ * Base mainnet (8453): **all real**. BatchExecutor now points at the
+ * canonical Coinbase Smart Wallet v2 contract which PAFI reuses as the
+ * EIP-7702 delegation target (no per-app deploy required — one
+ * contract, every issuer).
  *
- * Base mainnet (8453): all SC-delivered and real, EXCEPT `batchExecutor`
- * which is still a `0x...DE02` placeholder pending the Phase B delivery.
  * Base Sepolia (84532): entire row is placeholder — not in active use.
  *
  * ## What lives where
  *
  *   pointToken      — live POINT instance (clone of PointToken impl)
- *   batchExecutor   — EIP-7702 delegation target (PLACEHOLDER)
+ *   batchExecutor   — EIP-7702 delegation target (Coinbase Smart Wallet v2)
  *   usdt            — MockERC20 used by Uniswap pools
  *   issuerRegistry  — registry of all issuers on this chain
  *   mintingOracle   — per-issuer mint cap enforcer
+ *   pafiHook        — Uniswap V4 hook enforcing the 10% PT→USDT fee
  *
  * PointTokenFactory + PointToken implementation addresses live in
  * separate exports below — they're only needed at provisioning /
  * observability time, not in the hot mint/burn path, so excluded from
  * the per-chain bundle.
- *
- * ## Swap workflow when BatchExecutor lands
- *
- *   1. Replace `batchExecutor` placeholder with real address
- *   2. Structure / imports don't change — callers are stable
- *   3. Bump core to next beta and update release notes
  */
 interface ContractAddresses {
     pointToken: Address;
@@ -684,6 +929,13 @@ interface ContractAddresses {
     usdt: Address;
     issuerRegistry: Address;
     mintingOracle: Address;
+    /**
+     * Uniswap V4 hook that enforces the 10% fee on PT→USDT swaps
+     * (USDT→PT is free). FE reads this to build `PoolKey.hooks` when
+     * constructing a swap; quoters + routers need it to resolve the
+     * correct pool.
+     */
+    pafiHook: Address;
 }
 declare const CONTRACT_ADDRESSES: Record<number, ContractAddresses>;
 /**
@@ -1041,4 +1293,4 @@ declare class PafiSDK {
     signLoginMessage(message: string): Promise<Hex>;
 }
 
-export { ApiError, BATCH_EXECUTOR_ABI, BATCH_EXECUTOR_ADDRESS_BASE_MAINNET, BATCH_EXECUTOR_ADDRESS_BASE_SEPOLIA, BestQuote, type BuildPartialUserOpParams, COMMON_POOLS, COMMON_TOKENS, CONTRACT_ADDRESSES, ChainConfig, type CheckEthAndBranchParams, ConfigurationError, type ContractAddresses, EIP712Signature, LoginMessageParams, MintRequest, type ModalOpenOptions, Operation, POINT_TOKEN_FACTORY_ADDRESSES, POINT_TOKEN_IMPL_ADDRESSES, POINT_TOKEN_POOLS, POINT_TOKEN_ABI as POINT_TOKEN_V2_ABI, PafiSDK, PafiSDKConfig, PafiSDKError, type PafiWebModalAdapter, type PafiWebModalHandle, PartialUserOperation, type PaymasterConfig, PointTokenDomainConfig, PoolKey, QuoteResult, ReceiverConsent, SUPPORTED_CHAINS, type SignatureStruct, SignatureVerification, SigningError, SimulationError, type SponsorshipScenario, type SubmissionPath, SwapSimulationResult, UNIVERSAL_ROUTER_ADDRESSES, UserOperation, V4_QUOTER_ADDRESSES, _resetPaymasterConfigForTests, assembleUserOperation, buildPartialUserOperation, burnRequestTypes, checkEthAndBranch, encodeBatchExecute, erc20ApproveOp, erc20BurnOp, erc20TransferOp, getContractAddresses, getPafiWebModalAdapter, getPaymasterConfig, isPaymasterConfigured, mintRequestTypes, openPafiWebModal, openWebPopup, rawCallOp, receiverConsentTypes, setPafiWebModalAdapter, setPaymasterConfig, webPopupAdapter };
+export { ApiError, BATCH_EXECUTOR_ABI, BATCH_EXECUTOR_ADDRESS_BASE_MAINNET, BATCH_EXECUTOR_ADDRESS_BASE_SEPOLIA, BROKER_HASHES, BestQuote, type BuildPartialUserOpParams, type BuildPerpDepositWithGasDeductionParams, COMMON_POOLS, COMMON_TOKENS, CONTRACT_ADDRESSES, ChainConfig, type CheckEthAndBranchParams, ConfigurationError, type ContractAddresses, EIP712Signature, LoginMessageParams, MintRequest, type ModalOpenOptions, ORDERLY_VAULT_ABI, ORDERLY_VAULT_ADDRESSES, ORDERLY_VAULT_BASE_MAINNET, Operation, POINT_TOKEN_FACTORY_ADDRESSES, POINT_TOKEN_IMPL_ADDRESSES, POINT_TOKEN_POOLS, POINT_TOKEN_ABI as POINT_TOKEN_V2_ABI, PafiSDK, PafiSDKConfig, PafiSDKError, type PafiWebModalAdapter, type PafiWebModalHandle, PartialUserOperation, type PaymasterConfig, PointTokenDomainConfig, PoolKey, QuoteResult, ReceiverConsent, SUPPORTED_CHAINS, type SignatureStruct, SignatureVerification, SigningError, SimulationError, type SponsorshipScenario, type SubmissionPath, SwapSimulationResult, TOKEN_HASHES, UNIVERSAL_ROUTER_ADDRESSES, UserOperation, V4_QUOTER_ADDRESSES, type VaultDepositFE, _resetPaymasterConfigForTests, assembleUserOperation, buildPartialUserOperation, buildPerpDepositWithGasDeduction, burnRequestTypes, checkEthAndBranch, computeAccountId, encodeBatchExecute, erc20ApproveOp, erc20BurnOp, erc20TransferOp, getContractAddresses, getPafiWebModalAdapter, getPaymasterConfig, isPaymasterConfigured, mintRequestTypes, openPafiWebModal, openWebPopup, rawCallOp, receiverConsentTypes, setPafiWebModalAdapter, setPaymasterConfig, webPopupAdapter };

package/dist/index.js

@@ -93,6 +93,146 @@ import {
 // 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;
@@ -187,25 +327,27 @@ var POINT_TOKEN_ABI = parseAbi([
 
 // src/contracts/real/batchExecutor.ts
 var BATCH_EXECUTOR_ADDRESS_BASE_SEPOLIA = "0x000000000000000000000000000000000000DE01";
-var BATCH_EXECUTOR_ADDRESS_BASE_MAINNET = "0x000000000000000000000000000000000000DE02";
+var BATCH_EXECUTOR_ADDRESS_BASE_MAINNET = "0x7702cb554e6bFb442cb743A7dF23154544a7176C";
 
 // 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
-  // registry:   IssuerRegistry       0xda2D3338CF70F462Ac175F5f2edfa45660CA4f31
-  // factory:    PointTokenFactory    0x36c0BAb2faBE45EfA6d13001143e43A266Af673B
-  // oracle:     MintingOracle        0xD85165939C700E51c8a45099316C6482634C2Ab9
-  // tokenImpl:  PointToken (impl)    0x2e6FB1B0C1A51abb83eC974890126a64eC02E995
-  // mockUsdt:   MockERC20            0x5d313485Ba59C3bb91e1A9C0C11782F0b83d5dcd
-  // POINT:      PointToken instance  0x7d25E7156E51F865D522fd3ef257a6B5DD41b97e
+  // 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: {
     pointToken: "0x7d25E7156E51F865D522fd3ef257a6B5DD41b97e",
-    batchExecutor: PLACEHOLDER_DEAD("de02"),
-    // ⏳ pending SC delivery
+    batchExecutor: "0x7702cb554e6bFb442cb743A7dF23154544a7176C",
     usdt: "0x5d313485Ba59C3bb91e1A9C0C11782F0b83d5dcd",
     issuerRegistry: "0xda2D3338CF70F462Ac175F5f2edfa45660CA4f31",
-    mintingOracle: "0xD85165939C700E51c8a45099316C6482634C2Ab9"
+    mintingOracle: "0xD85165939C700E51c8a45099316C6482634C2Ab9",
+    pafiHook: "0x870cAF9882d3160602AaC1769C2B264A2d8EC044"
   },
   // Base Sepolia — not in active use; placeholders kept so the map
   // compiles for tooling that enumerates chains.
@@ -214,7 +356,8 @@ var CONTRACT_ADDRESSES = {
     batchExecutor: PLACEHOLDER_DEAD("de01"),
     usdt: PLACEHOLDER_DEAD("dead"),
     issuerRegistry: PLACEHOLDER_DEAD("dead"),
-    mintingOracle: PLACEHOLDER_DEAD("dead")
+    mintingOracle: PLACEHOLDER_DEAD("dead"),
+    pafiHook: PLACEHOLDER_DEAD("dead")
   }
 };
 var POINT_TOKEN_FACTORY_ADDRESSES = {
@@ -547,11 +690,15 @@ export {
   BATCH_EXECUTOR_ABI,
   BATCH_EXECUTOR_ADDRESS_BASE_MAINNET,
   BATCH_EXECUTOR_ADDRESS_BASE_SEPOLIA,
+  BROKER_HASHES,
   COMMON_POOLS,
   COMMON_TOKENS,
   CONTRACT_ADDRESSES,
   ConfigurationError,
   ENTRY_POINT_V07,
+  ORDERLY_VAULT_ABI,
+  ORDERLY_VAULT_ADDRESSES,
+  ORDERLY_VAULT_BASE_MAINNET,
   POINT_TOKEN_FACTORY_ADDRESSES,
   POINT_TOKEN_IMPL_ADDRESSES,
   POINT_TOKEN_POOLS,
@@ -564,6 +711,7 @@ export {
   SigningError,
   SimulationError,
   TAKE_ALL,
+  TOKEN_HASHES,
   UNIVERSAL_ROUTER_ADDRESSES,
   V4_QUOTER_ADDRESSES,
   V4_SWAP,
@@ -577,6 +725,7 @@ export {
   buildMintRequestTypedData,
   buildPartialUserOperation,
   buildPermit2ApprovalCalldata,
+  buildPerpDepositWithGasDeduction,
   buildReceiverConsentTypedData,
   buildSwapFromQuote,
   buildSwapWithGasDeduction,
@@ -586,6 +735,7 @@ export {
   checkAllowance,
   checkEthAndBranch,
   combineRoutes,
+  computeAccountId,
   createLoginMessage,
   encodeBatchExecute,
   erc20Abi,