@pafi-dev/core 0.2.0 → 0.3.0-beta.0

package/dist/index.d.cts

@@ -1,6 +1,6 @@
-import { Address, WalletClient, PublicClient, Hex } from 'viem';
-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-CkRJzrZr.cjs';
-export { I as Issuer } from './types-CkRJzrZr.cjs';
+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.cjs';
+export { I as Issuer } from './types-BDOnH5Le.cjs';
 export { erc20Abi, issuerRegistryAbi, mintingOracleAbi, permit2Abi, pointTokenAbi, pointTokenFactoryAbi, relayAbi, universalRouterAbi, v4QuoterAbi } from './abi/index.cjs';
 export { buildDomain, buildMintRequestTypedData, buildReceiverConsentTypedData, signMintRequest, signReceiverConsent, verifyMintRequest, verifyReceiverConsent } from './eip712/index.cjs';
 import { SimulationResult } from './relay/index.cjs';
@@ -74,6 +74,744 @@ declare class ApiError extends PafiSDKError {
     constructor(message: string, status?: number | undefined);
 }
 
+/**
+ * ERC-4337 v0.7 EntryPoint standard address (deployed deterministically
+ * at the same address across chains).
+ * https://eips.ethereum.org/EIPS/eip-4337
+ */
+declare const ENTRY_POINT_V07: Address;
+/**
+ * A single call inside a batch. `BatchExecutor.execute(Call[])` iterates
+ * and invokes each one. When the batch runs via EIP-7702 delegation,
+ * `msg.sender` for each call is the user's EOA.
+ */
+interface Operation {
+    target: Address;
+    value: bigint;
+    data: Hex;
+}
+/**
+ * Paymaster fields attached to a UserOperation. Populated by the
+ * Coinbase Paymaster (via PAFI Backend proxy) before the user signs.
+ */
+interface PaymasterFields {
+    paymaster: Address;
+    paymasterData: Hex;
+    paymasterVerificationGasLimit: bigint;
+    paymasterPostOpGasLimit: bigint;
+}
+/**
+ * Partial UserOp used during preparation — before paymaster fields are
+ * attached or the user signs.
+ */
+interface PartialUserOperation {
+    sender: Address;
+    nonce: bigint;
+    callData: Hex;
+    callGasLimit: bigint;
+    verificationGasLimit: bigint;
+    preVerificationGas: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+}
+/**
+ * Full ERC-4337 v0.7 UserOperation, ready for bundler submission.
+ */
+interface UserOperation extends PartialUserOperation {
+    paymaster: Address;
+    paymasterData: Hex;
+    paymasterVerificationGasLimit: bigint;
+    paymasterPostOpGasLimit: bigint;
+    signature: Hex;
+}
+/**
+ * Receipt returned by a bundler after a UserOp lands on-chain.
+ */
+interface UserOpReceipt {
+    userOpHash: Hex;
+    success: boolean;
+    txHash: Hex;
+    blockNumber: bigint;
+    gasUsed: bigint;
+    /** Effective gas cost paid (wei). */
+    actualGasCost: bigint;
+}
+/**
+ * Sentinel operation value used in tests + docs when `Operation.value`
+ * is irrelevant (ERC-20 transfers, for example).
+ */
+declare const ZERO_VALUE = 0n;
+
+/**
+ * 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
+ * the main action.
+ */
+declare function erc20TransferOp(token: Address, to: Address, amount: bigint): Operation;
+/**
+ * Build an ERC-20 `approve(spender, amount)` operation. Used inside a
+ * batch before a swap / deposit call so the AMM / protocol can pull
+ * tokens from the user.
+ */
+declare function erc20ApproveOp(token: Address, spender: Address, amount: bigint): Operation;
+/**
+ * Build an ERC-20 `burn(amount)` operation (OpenZeppelin ERC20Burnable
+ * extension). Burns from `msg.sender`, which — via EIP-7702 — is the
+ * user's EOA.
+ *
+ * Requires the PointToken contract to expose a public `burn(uint256)`
+ * without a role check. See
+ * [SDK_V1.4_TASKS.md §11 — PointToken.burn callable via batch].
+ */
+declare function erc20BurnOp(token: Address, amount: bigint): Operation;
+/**
+ * Build a raw call operation with caller-supplied calldata. Useful for
+ * non-ERC-20 contracts (PoolManager.swap, PerpDEX.deposit, Relayer.mint)
+ * where the encoding is specific to that protocol.
+ */
+declare function rawCallOp(target: Address, data: `0x${string}`, value?: bigint): Operation;
+
+/**
+ * Standard BatchExecutor ABI — a contract that takes an array of calls
+ * and invokes each one in sequence, reverting all if any fail.
+ *
+ * Compatible with OpenZeppelin `Account.execute(Call[])`, Biconomy
+ * `executeBatch`, Safe `MultiSend`, and most EIP-7702 delegation
+ * targets. The exact deployed address is supplied by the infra team
+ * (see [V1.4_V1.5_READINESS.md B2]).
+ */
+declare const BATCH_EXECUTOR_ABI: readonly [{
+    readonly name: "execute";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "target";
+        }, {
+            readonly type: "uint256";
+            readonly name: "value";
+        }, {
+            readonly type: "bytes";
+            readonly name: "data";
+        }];
+        readonly name: "calls";
+    }];
+    readonly outputs: readonly [];
+}];
+/**
+ * Encode a batch of operations into calldata for `BatchExecutor.execute()`.
+ * The resulting calldata goes into `UserOperation.callData`.
+ *
+ * When the EOA has an EIP-7702 delegation to a BatchExecutor, calling
+ * this calldata against the EOA runs all operations with
+ * `msg.sender = EOA` for each inner call.
+ *
+ * @param operations batch of calls, in execution order
+ * @returns calldata bytes for `execute((address,uint256,bytes)[])`
+ */
+declare function encodeBatchExecute(operations: Operation[]): Hex;
+
+interface BuildPartialUserOpParams {
+    /** User's EOA (with EIP-7702 delegation). */
+    sender: Address;
+    /** Batch of operations — encoded into callData via `encodeBatchExecute`. */
+    operations: Operation[];
+    /** EntryPoint nonce for this sender. Caller fetches from the EntryPoint contract. */
+    nonce: bigint;
+    /** Optional gas overrides; bundler re-estimates before submission. */
+    gasLimits?: {
+        callGasLimit?: bigint;
+        verificationGasLimit?: bigint;
+        preVerificationGas?: bigint;
+    };
+    /** Optional fee overrides; bundler usually fills these. */
+    feeOverrides?: {
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    };
+}
+/**
+ * Build a partial ERC-4337 UserOperation from a batch of operations.
+ * Paymaster fields and signature are populated later:
+ *   1. Call `PafiBackendClient.requestSponsorship()` → get paymaster fields
+ *   2. Compute userOpHash and have the user sign it (via Privy)
+ *   3. Attach `signature` → submit to bundler
+ *
+ * This function is a pure struct builder — no network calls.
+ */
+declare function buildPartialUserOperation(params: BuildPartialUserOpParams): PartialUserOperation;
+/**
+ * Assemble a full UserOperation once paymaster fields + signature are
+ * known. Used after `PafiBackendClient.requestSponsorship()` and user
+ * signing complete.
+ */
+declare function assembleUserOperation(partial: PartialUserOperation, paymaster: {
+    paymaster: Address;
+    paymasterData: `0x${string}`;
+    paymasterVerificationGasLimit: bigint;
+    paymasterPostOpGasLimit: bigint;
+}, signature: `0x${string}`): UserOperation;
+
+/**
+ * Module-level paymaster config shared by all batch builders and the
+ * `@pafi/issuer` RelayService. Holds the fee recipient address and the
+ * PAFI-assigned issuer identity.
+ *
+ * v1.4 update: the paymaster endpoint is **PAFI Backend**, which proxies
+ * to Coinbase Paymaster. See [SPONSORED_PATH_FLOW.md].
+ */
+interface PaymasterConfig {
+    /**
+     * PAFI Backend API base URL. Example:
+     *   https://api.pacificfinance.org/paymaster
+     */
+    pafiBackendUrl: string;
+    /** PAFI-assigned issuer ID. Passed in X-Issuer-Id header. */
+    issuerId: string;
+    /** Per-issuer API key (or JWT) for Authorization header. */
+    apiKey: string;
+    /**
+     * Where the fee transfer lands inside the batch call. Fee recovery is
+     * application-level — Paymaster sponsors gas, fee is a separate
+     * ERC-20 transfer inside the batch that reimburses the issuer.
+     */
+    feeRecipient: Address;
+    /** EIP-4337 EntryPoint address. Default: v0.7 (same across chains). */
+    entryPoint?: Address;
+    /** Chain ID the paymaster sponsors on. Defaults to consumer config. */
+    chainId?: number;
+}
+/**
+ * Which PAFI-defined scenario this UserOp represents. PAFI Backend
+ * validates the request's target contracts + function selectors
+ * match the expected pattern for the scenario.
+ */
+type SponsorshipScenario = "mint" | "burn" | "swap" | "perp-deposit";
+
+/**
+ * Set the application-wide paymaster config. Safe to call multiple
+ * times (later calls override earlier). Throws if required fields
+ * are missing.
+ */
+declare function setPaymasterConfig(config: PaymasterConfig): void;
+/**
+ * Get the current paymaster config. Throws if `setPaymasterConfig()`
+ * has not been called yet — this surfaces boot-order bugs early
+ * instead of failing with "paymaster.feeRecipient is undefined" at
+ * the point of use.
+ */
+declare function getPaymasterConfig(): PaymasterConfig;
+/** Test helper — clear the singleton. */
+declare function _resetPaymasterConfigForTests(): void;
+/** Check whether paymaster config has been initialized. */
+declare function isPaymasterConfigured(): boolean;
+
+/**
+ * Submission path chosen by `checkEthAndBranch`.
+ * - `normal`: initiator has enough ETH; submit via `walletClient.writeContract`
+ *   or a plain `eth_sendRawTransaction`. No paymaster round-trip.
+ * - `paymaster`: initiator doesn't have enough ETH; wrap the batch as a
+ *   UserOperation and route through PAFI Backend → Coinbase Paymaster
+ *   → Bundler.
+ */
+type SubmissionPath = "normal" | "paymaster";
+interface CheckEthAndBranchParams {
+    /** viem PublicClient bound to the target chain. */
+    client: PublicClient;
+    /** The address whose ETH balance we check. */
+    initiator: Address;
+    /** Estimated gas cost in wei for the upcoming tx. */
+    estimatedGasWei: bigint;
+    /**
+     * Optional safety margin multiplier (basis points). Defaults to
+     * 11_000 (110%) — the initiator needs 10% above the estimate to
+     * qualify for the normal path. Prevents edge cases where gas price
+     * spikes between estimation and submission cause a "has enough"
+     * decision to fail at broadcast time.
+     */
+    marginBps?: number;
+}
+/**
+ * Step 3 of the Generalized Flow ([SPONSORED_PATH_FLOW.md §2]):
+ * choose between the normal path (initiator pays ETH directly) and the
+ * paymaster path (bundler + Coinbase Paymaster).
+ *
+ * Intentionally synchronous in spirit — the only network call is
+ * `getBalance`. Callers can parallelize it with other reads.
+ */
+declare function checkEthAndBranch(params: CheckEthAndBranchParams): Promise<SubmissionPath>;
+
+/**
+ * ⚠️ MOCK — Relayer v2 `mint()` ABI for the v1.4 sponsored flow.
+ *
+ * Signature guess based on stakeholder memo (`REQUIREMENTS_V2.md §3`):
+ *
+ *   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
+ *   )
+ *
+ * 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
+ *
+ * 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.
+ *
+ * See [SC_MOCK_PLAN.md §2.1] for the rationale + swap checklist.
+ */
+declare const MOCK_RELAYER_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: "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 outputs: readonly [];
+}, {
+    readonly name: "mintRequestNonce";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "user";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "Minted";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "user";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }, {
+        readonly type: "uint256";
+        readonly name: "feeAmount";
+    }, {
+        readonly type: "address";
+        readonly name: "feeRecipient";
+        readonly indexed: true;
+    }, {
+        readonly type: "bytes32";
+        readonly name: "requestHash";
+    }];
+}];
+/**
+ * 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 type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "burnWithSig";
+    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 outputs: readonly [];
+}, {
+    readonly name: "balanceOf";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "user";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "burnNonce";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "user";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "Transfer";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "from";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "to";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint256";
+        readonly name: "value";
+    }];
+}];
+
+/**
+ * ⚠️ MOCK — placeholder BatchExecutor address.
+ *
+ * Real deployment:
+ *   - Coinbase may pre-deploy a canonical BatchExecutor that we target
+ *     via EIP-7702 delegation (see blocker B2 in V1.4_V1.5_READINESS.md)
+ *   - Otherwise PAFI deploys a minimal one and publishes the address
+ *
+ * The ABI itself (`execute(Call[])`) is stable and lives under
+ * `../../userop/batchExecute.ts` — that's the real one, unchanged
+ * by the mock swap. Only the **address** is mocked here.
+ *
+ * Pattern: checksum address with hex "DEAD0001" suffix per chain so
+ * it's obvious in logs which chain is using a mock.
+ */
+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.
+ *
+ * **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.
+ *
+ * Chain id map:
+ *   - 8453     Base mainnet
+ *   - 84532    Base Sepolia
+ *
+ * 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
+ */
+interface ContractAddresses {
+    relayerV2: Address;
+    pointToken: Address;
+    batchExecutor: Address;
+    usdt: Address;
+    issuerRegistry: Address;
+    mintingOracle: Address;
+}
+declare const MOCK_ADDRESSES: Record<number, ContractAddresses>;
+/**
+ * Lookup helper — throws if the chain isn't in the map so callers fail
+ * loudly on misconfiguration instead of silently using `undefined`.
+ */
+declare function getMockAddresses(chainId: number): ContractAddresses;
+
+/**
+ * ⚠️ MOCK — `MintRequest` v2 EIP-712 types.
+ *
+ * Extends v0.2.x `MintRequest` (4 fields) with three new fields needed
+ * for the v1.4 sponsored flow:
+ *
+ *   + 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.)
+ *
+ * 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).
+ */
+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.
+ */
+interface MockBurnConsent {
+    user: Address;
+    pointToken: Address;
+    amount: bigint;
+    nonce: bigint;
+    deadline: bigint;
+}
+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>;
+
 declare class PafiSDK {
     private _pointTokenAddress?;
     private _relayContractAddress?;
@@ -236,4 +974,4 @@ declare class PafiSDK {
     signLoginMessage(message: string): Promise<Hex>;
 }
 
-export { ApiError, BestQuote, COMMON_POOLS, COMMON_TOKENS, ChainConfig, ConfigurationError, EIP712Signature, LoginMessageParams, MintParams, MintRequest, POINT_TOKEN_POOLS, PafiSDK, PafiSDKConfig, PafiSDKError, PathKey, PointTokenDomainConfig, PoolKey, QuoteResult, ReceiverConsent, SUPPORTED_CHAINS, SignatureVerification, SigningError, SimulationError, SimulationResult, SwapParams, SwapSimulationResult, UNIVERSAL_ROUTER_ADDRESSES, V4_QUOTER_ADDRESSES, mintRequestTypes, receiverConsentTypes };
+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, ENTRY_POINT_V07, LoginMessageParams, MOCK_MINT_REQUEST_V2_TYPES as MINT_REQUEST_V2_TYPES, MintParams, MintRequest, type MockMintRequestV2 as MintRequestV2, type Operation, POINT_TOKEN_POOLS, MOCK_POINT_TOKEN_V2_ABI as POINT_TOKEN_V2_ABI, PafiSDK, PafiSDKConfig, PafiSDKError, type PartialUserOperation, PathKey, type PaymasterConfig, type PaymasterFields, 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, type UserOpReceipt, type UserOperation, V4_QUOTER_ADDRESSES, ZERO_VALUE, _resetPaymasterConfigForTests, assembleUserOperation, buildMockBurnConsentTypedData as buildBurnConsentTypedData, buildMockMintRequestV2TypedData as buildMintRequestV2TypedData, buildPartialUserOperation, checkEthAndBranch, encodeBatchExecute, erc20ApproveOp, erc20BurnOp, erc20TransferOp, getMockAddresses as getContractAddresses, getPaymasterConfig, isPaymasterConfigured, mintRequestTypes, rawCallOp, receiverConsentTypes, setPaymasterConfig, signMockBurnConsent as signBurnConsent, signMockMintRequestV2 as signMintRequestV2, verifyMockBurnConsent as verifyBurnConsent, verifyMockMintRequestV2 as verifyMintRequestV2 };