@pafi-dev/core 0.3.0-beta.2 → 0.3.0-beta.4

package/dist/index.d.ts

@@ -1,14 +1,14 @@
 import { Address, Hex, PublicClient, WalletClient } from 'viem';
-import { P as PoolKey, C as ChainConfig, a as PointTokenDomainConfig, E as EIP712Signature, S as SignatureVerification, b as PafiSDKConfig, M as MintRequest, R as ReceiverConsent, c as MintParams, d as SwapParams, B as BestQuote, Q as QuoteResult, e as PathKey } from './types-BDOnH5Le.js';
-export { I as Issuer } from './types-BDOnH5Le.js';
+import { P as PoolKey, C as ChainConfig, a as PafiSDKConfig, b as PointTokenDomainConfig, M as MintRequest, R as ReceiverConsent, E as EIP712Signature, S as SignatureVerification, c as MintParams, d as SwapParams, B as BestQuote, Q as QuoteResult, e as PathKey } from './types-DGDlKiDe.js';
+export { f as BurnRequest, I as Issuer } from './types-DGDlKiDe.js';
 export { erc20Abi, issuerRegistryAbi, mintingOracleAbi, permit2Abi, pointTokenAbi, pointTokenFactoryAbi, relayAbi, universalRouterAbi, v4QuoterAbi } from './abi/index.js';
-export { buildDomain, buildMintRequestTypedData, buildReceiverConsentTypedData, signMintRequest, signReceiverConsent, verifyMintRequest, verifyReceiverConsent } from './eip712/index.js';
+export { buildBurnRequestTypedData, buildDomain, buildMintRequestTypedData, buildReceiverConsentTypedData, signBurnRequest, signMintRequest, signReceiverConsent, verifyBurnRequest, verifyMintRequest, verifyReceiverConsent } from './eip712/index.js';
 import { SimulationResult } from './relay/index.js';
 export { buildRelaySwapParams, decodeExtData, decodeMintAndSwap, encodeExtData, encodeMintAndSwap, simulateMintAndSwap } from './relay/index.js';
 export { getIssuer, getMintRequestNonce, getPointTokenBalance, getPointTokenIssuer, getPointTokenIssuerAddress, getReceiverConsentNonce, getTokenName, getUsdt, 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-CNALKsH1.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-CNALKsH1.js';
+import { O as Operation, P as PartialUserOperation, U as UserOperation, S as SwapSimulationResult } from './index-BYL8Nn-n.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-BYL8Nn-n.js';
 import { LoginMessageParams } from './auth/index.js';
 export { VerifyLoginResult, createLoginMessage, parseLoginMessage, verifyLoginMessage } from './auth/index.js';
 
@@ -27,6 +27,21 @@ declare const mintRequestTypes: {
         readonly type: "uint256";
     }];
 };
+declare const burnRequestTypes: {
+    readonly BurnRequest: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
 declare const receiverConsentTypes: {
     readonly ReceiverConsent: readonly [{
         readonly name: "onBehalfOf";
@@ -276,238 +291,290 @@ interface CheckEthAndBranchParams {
 declare function checkEthAndBranch(params: CheckEthAndBranchParams): Promise<SubmissionPath>;
 
 /**
- * ⚠️ MOCK — Relayer v2 `mint()` ABI for the v1.4 sponsored flow.
+ * ⚠️ PARTIAL MOCK — `PointToken` ABI.
+ *
+ * As of 2026-04-21 this matches the deployed Base mainnet contract
+ * (POINT at `0x7d25E7156E51F865D522fd3ef257a6B5DD41b97e`). The ABI
+ * itself is no longer mocked — kept under `mocks/` only because the
+ * rest of the folder is still mock (pending BatchExecutor real address).
+ * Once Phase B completes, this file moves to `contracts/real/`.
+ *
+ * ## Mint — two paths
+ *
+ *   Path 1 — Direct (whitelisted minter):
+ *     mint(address to, uint256 amount)
+ *     - msg.sender must be in minters[]
+ *     - Used by off-chain services that hold a minter key
+ *
+ *   Path 2 — Sig-gated (gasless, v1.4 sponsored flow):
+ *     mint(address to, uint256 amount, uint256 deadline, bytes minterSig)
+ *     - msg.sender MUST equal `to` (the receiver)
+ *     - minterSig is an EIP-712 MintRequest signature from a whitelisted minter
+ *     - Consumes `mintRequestNonces[to]`
+ *     - This is the path v1.4 uses: issuer backend signs, user submits
+ *       via EIP-7702 + Coinbase Paymaster
  *
- * Signature guess based on stakeholder memo (`REQUIREMENTS_V2.md §3`):
+ * ## Burn — mirror structure
  *
- *   mint(
- *     MintRequest request,      // EIP-712 signed by user + issuer
- *     Signature userSig,        // v, r, s
- *     Signature issuerSig,      // v, r, s
- *     uint256 feeAmount,        // PT units to split off to feeRecipient
- *     address feeRecipient      // typically operator or fee collector
- *   )
+ *   Path 1: burn(address from, uint256 amount) — whitelisted burner
+ *   Path 2: burn(address from, uint256 amount, uint256 deadline, bytes burnerSig)
+ *           — msg.sender must equal `from`, burnerSig from whitelisted burner,
+ *           consumes `burnRequestNonces[from]`
  *
- * Behaviour expected:
- *   - Verify user + issuer EIP-712 signatures against `request`
- *   - Mint `request.amount` PT to `request.to`
- *   - Atomic transfer `feeAmount` from `request.to` → `feeRecipient`
- *     (net mint = `amount - feeAmount`)
- *   - Increment the on-chain nonce to prevent replay
+ * Either burn path emits `Transfer(from → 0x0)` so BurnIndexer semantics
+ * don't depend on which path was taken.
  *
- * When SC team publishes the real ABI, drop it in under
- * `src/contracts/real/relayerV2.abi.ts` and flip the export in
- * `src/contracts/index.ts` — call sites unchanged.
+ * ## EIP-712 type hashes (from contract source)
  *
- * See [SC_MOCK_PLAN.md §2.1] for the rationale + swap checklist.
+ *   MintRequest(address to,uint256 amount,uint256 nonce,uint256 deadline)
+ *   BurnRequest(address from,uint256 amount,uint256 nonce,uint256 deadline)
+ *
+ *   Domain: EIP-712 standard — name = ERC-20 token name, version = "1",
+ *   chainId, verifyingContract = this PointToken address.
  */
-declare const MOCK_RELAYER_V2_ABI: readonly [{
+declare const MOCK_POINT_TOKEN_V2_ABI: readonly [{
     readonly name: "mint";
     readonly type: "function";
     readonly stateMutability: "nonpayable";
     readonly inputs: readonly [{
-        readonly type: "tuple";
-        readonly components: readonly [{
-            readonly type: "address";
-            readonly name: "to";
-        }, {
-            readonly type: "uint256";
-            readonly name: "amount";
-        }, {
-            readonly type: "uint256";
-            readonly name: "feeAmount";
-        }, {
-            readonly type: "address";
-            readonly name: "feeRecipient";
-        }, {
-            readonly type: "uint256";
-            readonly name: "nonce";
-        }, {
-            readonly type: "uint256";
-            readonly name: "deadline";
-        }, {
-            readonly type: "bytes";
-            readonly name: "extData";
-        }];
-        readonly name: "request";
-    }, {
-        readonly type: "tuple";
-        readonly components: readonly [{
-            readonly type: "uint8";
-            readonly name: "v";
-        }, {
-            readonly type: "bytes32";
-            readonly name: "r";
-        }, {
-            readonly type: "bytes32";
-            readonly name: "s";
-        }];
-        readonly name: "userSig";
+        readonly type: "address";
+        readonly name: "to";
     }, {
-        readonly type: "tuple";
-        readonly components: readonly [{
-            readonly type: "uint8";
-            readonly name: "v";
-        }, {
-            readonly type: "bytes32";
-            readonly name: "r";
-        }, {
-            readonly type: "bytes32";
-            readonly name: "s";
-        }];
-        readonly name: "issuerSig";
+        readonly type: "uint256";
+        readonly name: "amount";
     }];
     readonly outputs: readonly [];
 }, {
-    readonly name: "mintRequestNonce";
+    readonly name: "mint";
     readonly type: "function";
-    readonly stateMutability: "view";
+    readonly stateMutability: "nonpayable";
     readonly inputs: readonly [{
         readonly type: "address";
-        readonly name: "user";
+        readonly name: "to";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }, {
+        readonly type: "uint256";
+        readonly name: "deadline";
+    }, {
+        readonly type: "bytes";
+        readonly name: "minterSig";
     }];
-    readonly outputs: readonly [{
+    readonly outputs: readonly [];
+}, {
+    readonly name: "burn";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "from";
+    }, {
         readonly type: "uint256";
+        readonly name: "amount";
     }];
+    readonly outputs: readonly [];
 }, {
-    readonly name: "Minted";
-    readonly type: "event";
+    readonly name: "burn";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
     readonly inputs: readonly [{
         readonly type: "address";
-        readonly name: "user";
-        readonly indexed: true;
+        readonly name: "from";
     }, {
         readonly type: "uint256";
         readonly name: "amount";
     }, {
         readonly type: "uint256";
-        readonly name: "feeAmount";
+        readonly name: "deadline";
     }, {
+        readonly type: "bytes";
+        readonly name: "burnerSig";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "minters";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
         readonly type: "address";
-        readonly name: "feeRecipient";
-        readonly indexed: true;
-    }, {
-        readonly type: "bytes32";
-        readonly name: "requestHash";
+        readonly name: "account";
     }];
-}];
-/**
- * Calldata function selector for `mint((...),(...),(...))` as encoded
- * by viem against {@link MOCK_RELAYER_V2_ABI}. Callers compare against
- * this to sanity-check decoded UserOp inner calls.
- *
- * Recompute when the real ABI lands — almost certainly differs.
- */
-declare const MOCK_RELAYER_V2_MINT_SELECTOR: "0xMOCKED__";
-/**
- * Struct shape that matches {@link MOCK_RELAYER_V2_ABI}. Exported so
- * builders can accept a typed input without `as const` gymnastics.
- */
-interface MockMintRequestV2 {
-    to: Address;
-    amount: bigint;
-    feeAmount: bigint;
-    feeRecipient: Address;
-    nonce: bigint;
-    deadline: bigint;
-    extData: `0x${string}`;
-}
-interface MockSignatureStruct {
-    v: number;
-    r: `0x${string}`;
-    s: `0x${string}`;
-}
-
-/**
- * ⚠️ MOCK — `PointToken` v1.4 burn surface.
- *
- * Two variants mocked — SC team will pick ONE before stable; the other
- * gets deleted during Phase B swap.
- *
- *   Variant A (simpler, most likely):
- *     burn(uint256 amount)
- *     - burns from `msg.sender`
- *     - caller handles authorization (the user is `msg.sender` via
- *       EIP-7702 delegation, so `msg.sender == user`)
- *
- *   Variant B (signature-based, if SC prefers explicit consent on-chain):
- *     burnWithSig(BurnConsent consent, Signature sig)
- *     - verifies EIP-712 signature before burning
- *     - used when the caller isn't the user (e.g. a relayer burns on
- *       behalf of the user)
- *
- * Either way the ERC-20 emits `Transfer(from, address(0), amount)` so
- * `BurnIndexer` semantics don't change.
- */
-declare const MOCK_POINT_TOKEN_V2_ABI: readonly [{
-    readonly name: "burn";
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "burners";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "account";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "addMinter";
     readonly type: "function";
     readonly stateMutability: "nonpayable";
     readonly inputs: readonly [{
-        readonly type: "uint256";
-        readonly name: "amount";
+        readonly type: "address";
+        readonly name: "minter";
     }];
     readonly outputs: readonly [];
 }, {
-    readonly name: "burnWithSig";
+    readonly name: "removeMinter";
     readonly type: "function";
     readonly stateMutability: "nonpayable";
     readonly inputs: readonly [{
-        readonly type: "tuple";
-        readonly components: readonly [{
-            readonly type: "address";
-            readonly name: "user";
-        }, {
-            readonly type: "address";
-            readonly name: "pointToken";
-        }, {
-            readonly type: "uint256";
-            readonly name: "amount";
-        }, {
-            readonly type: "uint256";
-            readonly name: "nonce";
-        }, {
-            readonly type: "uint256";
-            readonly name: "deadline";
-        }];
-        readonly name: "consent";
-    }, {
-        readonly type: "tuple";
-        readonly components: readonly [{
-            readonly type: "uint8";
-            readonly name: "v";
-        }, {
-            readonly type: "bytes32";
-            readonly name: "r";
-        }, {
-            readonly type: "bytes32";
-            readonly name: "s";
-        }];
-        readonly name: "sig";
+        readonly type: "address";
+        readonly name: "minter";
     }];
     readonly outputs: readonly [];
 }, {
-    readonly name: "balanceOf";
+    readonly name: "addBurner";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "burner";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "removeBurner";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "burner";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "mintRequestNonces";
     readonly type: "function";
     readonly stateMutability: "view";
     readonly inputs: readonly [{
         readonly type: "address";
-        readonly name: "user";
+        readonly name: "receiver";
     }];
     readonly outputs: readonly [{
         readonly type: "uint256";
     }];
 }, {
-    readonly name: "burnNonce";
+    readonly name: "burnRequestNonces";
     readonly type: "function";
     readonly stateMutability: "view";
     readonly inputs: readonly [{
         readonly type: "address";
-        readonly name: "user";
+        readonly name: "from";
     }];
     readonly outputs: readonly [{
         readonly type: "uint256";
     }];
+}, {
+    readonly name: "mintingOracle";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "setMintingOracle";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "_mintingOracle";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "issuer";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "balanceOf";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "account";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "totalSupply";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "name";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly name: "symbol";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly name: "decimals";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint8";
+    }];
+}, {
+    readonly name: "DOMAIN_SEPARATOR";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bytes32";
+    }];
+}, {
+    readonly name: "eip712Domain";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bytes1";
+        readonly name: "fields";
+    }, {
+        readonly type: "string";
+        readonly name: "name";
+    }, {
+        readonly type: "string";
+        readonly name: "version";
+    }, {
+        readonly type: "uint256";
+        readonly name: "chainId";
+    }, {
+        readonly type: "address";
+        readonly name: "verifyingContract";
+    }, {
+        readonly type: "bytes32";
+        readonly name: "salt";
+    }, {
+        readonly type: "uint256[]";
+        readonly name: "extensions";
+    }];
 }, {
     readonly name: "Transfer";
     readonly type: "event";
@@ -523,6 +590,46 @@ declare const MOCK_POINT_TOKEN_V2_ABI: readonly [{
         readonly type: "uint256";
         readonly name: "value";
     }];
+}, {
+    readonly name: "MinterAdded";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "minter";
+        readonly indexed: true;
+    }];
+}, {
+    readonly name: "MinterRemoved";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "minter";
+        readonly indexed: true;
+    }];
+}, {
+    readonly name: "BurnerAdded";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "burner";
+        readonly indexed: true;
+    }];
+}, {
+    readonly name: "BurnerRemoved";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "burner";
+        readonly indexed: true;
+    }];
+}, {
+    readonly name: "MintingOracleUpdated";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "mintingOracle";
+        readonly indexed: true;
+    }];
 }];
 
 /**
@@ -544,29 +651,34 @@ declare const MOCK_BATCH_EXECUTOR_ADDRESS_BASE_SEPOLIA: Address;
 declare const MOCK_BATCH_EXECUTOR_ADDRESS_BASE_MAINNET: Address;
 
 /**
- * ⚠️ MOCK — per-chain contract addresses for the v1.4 sponsored flow.
- *
- * Real addresses come from SC team once they deploy Relayer v2 and
- * pick a BatchExecutor. Until then we use placeholders so the SDK
- * code path compiles + tests execute end-to-end.
+ * ⚠️ PARTIAL MOCK — per-chain contract addresses for the v1.4 flow.
  *
- * **Intentionally not merge-safe to mainnet** — callers that resolve
- * a mainnet address here get a `0x...DEAD` placeholder which will
- * revert at contract-level. That's the point: prod refuses to run
- * on mocks.
+ * As of 2026-04-21 SC team delivered the first round of deployed
+ * addresses on Base mainnet. `batchExecutor` is still pending (not
+ * part of the first deploy batch) so that single field remains a
+ * placeholder until Phase B.
  *
  * Chain id map:
- *   - 8453     Base mainnet
- *   - 84532    Base Sepolia
+ *   - 8453     Base mainnet — SC-delivered (see below)
+ *   - 84532    Base Sepolia — not in use; placeholders only
+ *
+ * v1.4 notes:
+ *   - No `relayerV2` — flow dropped the intermediate Relayer contract.
+ *     User submits UserOp that calls `PointToken.mint(...)` directly.
+ *   - `pointToken` here is the live deployed POINT instance (clone
+ *     from PointTokenFactory) — not the implementation. The impl
+ *     lives at tokenImpl and is only referenced by the factory.
+ *   - `usdt` is the MockERC20 (dev USDT) used by Uniswap pools.
  *
- * Swap workflow when SC delivers:
- *   1. Rename this file → `addresses.ts` under `src/contracts/real/`
- *   2. Fill real addresses per chain
- *   3. Update `src/contracts/index.ts` re-export
- *   4. Delete MOCK_* named exports
+ * Swap workflow when BatchExecutor lands:
+ *   1. Replace `batchExecutor` placeholder with real address
+ *   2. Keep structure — consumers already import from the same key
+ *   3. Bump core to `0.3.0-beta.N+1`
+ */
+/**
+ * Per-chain contract addresses.
  */
 interface ContractAddresses {
-    relayerV2: Address;
     pointToken: Address;
     batchExecutor: Address;
     usdt: Address;
@@ -574,6 +686,18 @@ interface ContractAddresses {
     mintingOracle: Address;
 }
 declare const MOCK_ADDRESSES: Record<number, ContractAddresses>;
+/**
+ * PointTokenFactory address — separate from `ContractAddresses`
+ * because it's only used at provisioning time (issuer onboard +
+ * token creation), not in the hot mint/burn path.
+ */
+declare const POINT_TOKEN_FACTORY_ADDRESSES: Record<number, Address>;
+/**
+ * PointToken implementation address — the EIP-1167 clone target used
+ * by PointTokenFactory. Exposed for observability / proxy verification;
+ * consumers should never call this directly.
+ */
+declare const POINT_TOKEN_IMPL_ADDRESSES: Record<number, Address>;
 /**
  * Lookup helper — throws if the chain isn't in the map so callers fail
  * loudly on misconfiguration instead of silently using `undefined`.
@@ -581,168 +705,48 @@ declare const MOCK_ADDRESSES: Record<number, ContractAddresses>;
 declare function getMockAddresses(chainId: number): ContractAddresses;
 
 /**
- * ⚠️ MOCK — `MintRequest` v2 EIP-712 types.
+ * Public contract surface for `@pafi-dev/core/contracts`.
  *
- * Extends v0.2.x `MintRequest` (4 fields) with three new fields needed
- * for the v1.4 sponsored flow:
+ * Consumers import ABIs + per-chain addresses from this module. EIP-712
+ * helpers (`signMintRequest`, `signBurnRequest`, etc.) live under
+ * `./eip712/` and are re-exported from the package root — not duplicated
+ * here.
  *
- *   + feeAmount      PT units taken from the mint for the operator
- *   + feeRecipient   where the fee goes (operator or treasury)
- *   + extData        arbitrary bytes for future extensions (swap path, etc.)
+ * ## v1.4 flow — no Relayer, sig-gated mint/burn
  *
- * When SC team confirms the real struct, drop this file's content into
- * the real builder and remove the MOCK_ prefix. The function signatures
- * below stay stable — only `MOCK_MINT_REQUEST_V2_TYPES` changes.
- */
-declare const MOCK_MINT_REQUEST_V2_TYPES: {
-    readonly MintRequest: readonly [{
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly name: "amount";
-        readonly type: "uint256";
-    }, {
-        readonly name: "feeAmount";
-        readonly type: "uint256";
-    }, {
-        readonly name: "feeRecipient";
-        readonly type: "address";
-    }, {
-        readonly name: "nonce";
-        readonly type: "uint256";
-    }, {
-        readonly name: "deadline";
-        readonly type: "uint256";
-    }, {
-        readonly name: "extData";
-        readonly type: "bytes";
-    }];
-};
-/**
- * Build the typed-data envelope that any EIP-712 signer (viem, ethers,
- * Privy) can consume. Callers typically pass the result to
- * `walletClient.signTypedData()` or `privy.signTypedData()`.
- */
-declare function buildMockMintRequestV2TypedData(domain: PointTokenDomainConfig, message: MockMintRequestV2): {
-    domain: {
-        name: string;
-        version: "1";
-        chainId: number;
-        verifyingContract: `0x${string}`;
-    };
-    types: {
-        readonly MintRequest: readonly [{
-            readonly name: "to";
-            readonly type: "address";
-        }, {
-            readonly name: "amount";
-            readonly type: "uint256";
-        }, {
-            readonly name: "feeAmount";
-            readonly type: "uint256";
-        }, {
-            readonly name: "feeRecipient";
-            readonly type: "address";
-        }, {
-            readonly name: "nonce";
-            readonly type: "uint256";
-        }, {
-            readonly name: "deadline";
-            readonly type: "uint256";
-        }, {
-            readonly name: "extData";
-            readonly type: "bytes";
-        }];
-    };
-    primaryType: "MintRequest";
-    message: MockMintRequestV2;
-};
-/**
- * Sign a `MintRequest` v2 with a viem WalletClient — server-side flow
- * where the issuer holds the private key directly (KMS-backed signer
- * is the production path; see `@pafi-dev/issuer` KMSSignerAdapter).
- */
-declare function signMockMintRequestV2(walletClient: WalletClient, domain: PointTokenDomainConfig, message: MockMintRequestV2): Promise<EIP712Signature>;
-/**
- * Verify a `MintRequest` v2 signature and check it came from the
- * expected signer (either user or issuer depending on which side is
- * being verified).
+ * Relayer contract dropped. Users call `PointToken.mint(to, amount,
+ * deadline, minterSig)` directly via an EIP-7702 delegated UserOp —
+ * `msg.sender == user == to`. `minterSig` is an EIP-712 `MintRequest`
+ * signed off-chain by the issuer's minter signer (HSM/KMS). Mirror
+ * structure on the burn side with `BurnRequest` + `burn(from, amount,
+ * deadline, burnerSig)`.
+ *
+ * Exports:
+ *   - `POINT_TOKEN_V2_ABI`    — full mint + burn + admin surface
+ *   - `BATCH_EXECUTOR_*`      — EIP-7702 delegation target (ABI real,
+ *                               address placeholder on all chains until
+ *                               SC delivers)
+ *   - `CONTRACT_ADDRESSES`    — per-chain map (real on 8453 except
+ *                               `batchExecutor` — pending SC)
+ *   - `POINT_TOKEN_FACTORY_ADDRESSES`, `POINT_TOKEN_IMPL_ADDRESSES`
+ *                             — provisioning / observability helpers
+ *
+ * Status: PARTIAL mock. Only `batchExecutor` on Base mainnet + the
+ * entire Base Sepolia row are still placeholder. See mocks/README.md
+ * for the deletion checklist.
  */
-declare function verifyMockMintRequestV2(domain: PointTokenDomainConfig, message: MockMintRequestV2, signature: Hex, expectedSigner: Address): Promise<SignatureVerification>;
 
 /**
- * ⚠️ MOCK — `BurnConsent` EIP-712 type for the v1.4 reverse flow.
- *
- * New type entirely — v0.2.x had no burn-for-credit flow.
- *
- * User signs `BurnConsent` to authorize burning `amount` PT from their
- * wallet in exchange for an off-chain credit of (amount - gasFee).
- * Signature is consumed either by:
- *   - A relayer calling `PointToken.burnWithSig(...)` (Variant B)
- *   - The paymaster-proxy-sponsored UserOp calling `PointToken.burn(...)`
- *     with msg.sender = user via EIP-7702 (Variant A)
- *
- * Either way the tx emits `Transfer(user → 0x0)` which the issuer's
- * `BurnIndexer` watches for and uses to credit the off-chain ledger.
- *
- * Field list is a best-guess — SC team may add fields (e.g. `feeAmount`
- * explicit, `extData`). Update this mock when they freeze the spec.
+ * Signature struct — kept for consumers that want the tuple form.
+ * Most v1.4 paths pass `bytes` (serialized signature) directly to the
+ * contract; this struct is only needed if you're manually splitting
+ * for other on-chain verifiers.
  */
-interface MockBurnConsent {
-    user: Address;
-    pointToken: Address;
-    amount: bigint;
-    nonce: bigint;
-    deadline: bigint;
+interface SignatureStruct {
+    v: number;
+    r: `0x${string}`;
+    s: `0x${string}`;
 }
-declare const MOCK_BURN_CONSENT_TYPES: {
-    readonly BurnConsent: readonly [{
-        readonly name: "user";
-        readonly type: "address";
-    }, {
-        readonly name: "pointToken";
-        readonly type: "address";
-    }, {
-        readonly name: "amount";
-        readonly type: "uint256";
-    }, {
-        readonly name: "nonce";
-        readonly type: "uint256";
-    }, {
-        readonly name: "deadline";
-        readonly type: "uint256";
-    }];
-};
-declare function buildMockBurnConsentTypedData(domain: PointTokenDomainConfig, message: MockBurnConsent): {
-    domain: {
-        name: string;
-        version: "1";
-        chainId: number;
-        verifyingContract: `0x${string}`;
-    };
-    types: {
-        readonly BurnConsent: readonly [{
-            readonly name: "user";
-            readonly type: "address";
-        }, {
-            readonly name: "pointToken";
-            readonly type: "address";
-        }, {
-            readonly name: "amount";
-            readonly type: "uint256";
-        }, {
-            readonly name: "nonce";
-            readonly type: "uint256";
-        }, {
-            readonly name: "deadline";
-            readonly type: "uint256";
-        }];
-    };
-    primaryType: "BurnConsent";
-    message: MockBurnConsent;
-};
-declare function signMockBurnConsent(walletClient: WalletClient, domain: PointTokenDomainConfig, message: MockBurnConsent): Promise<EIP712Signature>;
-declare function verifyMockBurnConsent(domain: PointTokenDomainConfig, message: MockBurnConsent, signature: Hex, expectedUser: Address): Promise<SignatureVerification>;
 
 /**
  * Options for opening a PAFI Web modal — passed through by all adapters.
@@ -1088,4 +1092,4 @@ declare class PafiSDK {
     signLoginMessage(message: string): Promise<Hex>;
 }
 
-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, BestQuote, type BuildPartialUserOpParams, type MockBurnConsent as BurnConsent, COMMON_POOLS, COMMON_TOKENS, MOCK_ADDRESSES as CONTRACT_ADDRESSES, ChainConfig, type CheckEthAndBranchParams, ConfigurationError, type ContractAddresses, EIP712Signature, LoginMessageParams, MOCK_MINT_REQUEST_V2_TYPES as MINT_REQUEST_V2_TYPES, MintParams, MintRequest, type MockMintRequestV2 as MintRequestV2, type ModalOpenOptions, Operation, POINT_TOKEN_POOLS, MOCK_POINT_TOKEN_V2_ABI as POINT_TOKEN_V2_ABI, PafiSDK, PafiSDKConfig, PafiSDKError, type PafiWebModalAdapter, type PafiWebModalHandle, PartialUserOperation, PathKey, type PaymasterConfig, PointTokenDomainConfig, PoolKey, QuoteResult, MOCK_RELAYER_V2_ABI as RELAYER_V2_ABI, MOCK_RELAYER_V2_MINT_SELECTOR as RELAYER_V2_MINT_SELECTOR, ReceiverConsent, SUPPORTED_CHAINS, type MockSignatureStruct as SignatureStruct, SignatureVerification, SigningError, SimulationError, SimulationResult, type SponsorshipScenario, type SubmissionPath, SwapParams, SwapSimulationResult, UNIVERSAL_ROUTER_ADDRESSES, UserOperation, V4_QUOTER_ADDRESSES, _resetPaymasterConfigForTests, assembleUserOperation, buildMockBurnConsentTypedData as buildBurnConsentTypedData, buildMockMintRequestV2TypedData as buildMintRequestV2TypedData, buildPartialUserOperation, checkEthAndBranch, encodeBatchExecute, erc20ApproveOp, erc20BurnOp, erc20TransferOp, getMockAddresses as getContractAddresses, getPafiWebModalAdapter, getPaymasterConfig, isPaymasterConfigured, mintRequestTypes, openPafiWebModal, openWebPopup, rawCallOp, receiverConsentTypes, setPafiWebModalAdapter, setPaymasterConfig, signMockBurnConsent as signBurnConsent, signMockMintRequestV2 as signMintRequestV2, verifyMockBurnConsent as verifyBurnConsent, verifyMockMintRequestV2 as verifyMintRequestV2, webPopupAdapter };
+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, BestQuote, type BuildPartialUserOpParams, COMMON_POOLS, COMMON_TOKENS, MOCK_ADDRESSES as CONTRACT_ADDRESSES, ChainConfig, type CheckEthAndBranchParams, ConfigurationError, type ContractAddresses, EIP712Signature, LoginMessageParams, MintParams, MintRequest, type ModalOpenOptions, Operation, POINT_TOKEN_FACTORY_ADDRESSES, POINT_TOKEN_IMPL_ADDRESSES, POINT_TOKEN_POOLS, MOCK_POINT_TOKEN_V2_ABI as POINT_TOKEN_V2_ABI, PafiSDK, PafiSDKConfig, PafiSDKError, type PafiWebModalAdapter, type PafiWebModalHandle, PartialUserOperation, PathKey, type PaymasterConfig, PointTokenDomainConfig, PoolKey, QuoteResult, ReceiverConsent, SUPPORTED_CHAINS, type SignatureStruct, SignatureVerification, SigningError, SimulationError, SimulationResult, type SponsorshipScenario, type SubmissionPath, SwapParams, SwapSimulationResult, UNIVERSAL_ROUTER_ADDRESSES, UserOperation, V4_QUOTER_ADDRESSES, _resetPaymasterConfigForTests, assembleUserOperation, buildPartialUserOperation, burnRequestTypes, checkEthAndBranch, encodeBatchExecute, erc20ApproveOp, erc20BurnOp, erc20TransferOp, getMockAddresses as getContractAddresses, getPafiWebModalAdapter, getPaymasterConfig, isPaymasterConfigured, mintRequestTypes, openPafiWebModal, openWebPopup, rawCallOp, receiverConsentTypes, setPafiWebModalAdapter, setPaymasterConfig, webPopupAdapter };