@pafi-dev/core 0.3.0-alpha.0 → 0.3.0-beta.1

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 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.js';
-export { I as Issuer } from './types-CkRJzrZr.js';
+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';
 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';
 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 { SwapSimulationResult } from './swap/index.js';
-export { SETTLE_ALL, SWAP_EXACT_IN, TAKE_ALL, V4_SWAP, buildErc20ApprovalCalldata, buildPermit2ApprovalCalldata, buildSwapFromQuote, buildUniversalRouterExecuteArgs, buildV4SwapInput, checkAllowance, simulateSwap } from './swap/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 { LoginMessageParams } from './auth/index.js';
 export { VerifyLoginResult, createLoginMessage, parseLoginMessage, verifyLoginMessage } from './auth/index.js';
 
@@ -74,74 +74,6 @@ 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
@@ -343,6 +275,475 @@ interface CheckEthAndBranchParams {
  */
 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?;
@@ -505,4 +906,4 @@ declare class PafiSDK {
     signLoginMessage(message: string): Promise<Hex>;
 }
 
-export { ApiError, BATCH_EXECUTOR_ABI, BestQuote, type BuildPartialUserOpParams, COMMON_POOLS, COMMON_TOKENS, ChainConfig, type CheckEthAndBranchParams, ConfigurationError, EIP712Signature, ENTRY_POINT_V07, LoginMessageParams, MintParams, MintRequest, type Operation, POINT_TOKEN_POOLS, PafiSDK, PafiSDKConfig, PafiSDKError, type PartialUserOperation, PathKey, type PaymasterConfig, type PaymasterFields, PointTokenDomainConfig, PoolKey, QuoteResult, ReceiverConsent, SUPPORTED_CHAINS, SignatureVerification, SigningError, SimulationError, SimulationResult, type SponsorshipScenario, type SubmissionPath, SwapParams, SwapSimulationResult, UNIVERSAL_ROUTER_ADDRESSES, type UserOpReceipt, type UserOperation, V4_QUOTER_ADDRESSES, ZERO_VALUE, _resetPaymasterConfigForTests, assembleUserOperation, buildPartialUserOperation, checkEthAndBranch, encodeBatchExecute, erc20ApproveOp, erc20BurnOp, erc20TransferOp, getPaymasterConfig, isPaymasterConfigured, mintRequestTypes, rawCallOp, receiverConsentTypes, setPaymasterConfig };
+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, Operation, POINT_TOKEN_POOLS, MOCK_POINT_TOKEN_V2_ABI as POINT_TOKEN_V2_ABI, PafiSDK, PafiSDKConfig, PafiSDKError, 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, getPaymasterConfig, isPaymasterConfigured, mintRequestTypes, rawCallOp, receiverConsentTypes, setPaymasterConfig, signMockBurnConsent as signBurnConsent, signMockMintRequestV2 as signMintRequestV2, verifyMockBurnConsent as verifyBurnConsent, verifyMockMintRequestV2 as verifyMintRequestV2 };