@pafi-dev/issuer 0.3.0-beta.4 → 0.3.0-beta.6

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { Address, Hex, PublicClient, Chain, WalletClient } from 'viem';
-import { PointTokenDomainConfig, MintRequest, EIP712Signature, MintParams, SwapParams, PartialUserOperation, BurnRequest, ReceiverConsent, PathKey, PoolKey, SponsorshipScenario } from '@pafi-dev/core';
-export { encodeExtData } from '@pafi-dev/core';
+import { PointTokenDomainConfig, MintRequest, EIP712Signature, PartialUserOperation, BurnRequest, ReceiverConsent, PathKey, PoolKey, SponsorshipScenario } from '@pafi-dev/core';
 
 /**
  * Lifecycle of a minting request as tracked by the issuer's point ledger.
@@ -449,130 +448,40 @@ declare class AuthError extends Error {
 }
 
 /**
- * Parameters for a single `mintAndSwap` relay submission. This is the
- * exact shape the Relay contract expects, with the two structs the
- * `@pafi/core` calldata helpers build. The RelayService wires these
- * through viem's `writeContract`.
- */
-interface SubmitMintAndSwapParams {
-    mint: MintParams;
-    swap: SwapParams;
-}
-/**
- * Result of a relay submission. `txHash` is returned immediately after
- * the tx is broadcast; `receipt` is present only when the caller opted to
- * wait for confirmation.
- */
-interface RelayResult {
-    txHash: Hex;
-    blockNumber?: bigint;
-    gasUsed?: bigint;
-    status?: "success" | "reverted";
-}
-/**
- * Errors raised by RelayService carry a `code` so the MintingGateway (or
- * any caller) can decide whether to release the ledger lock.
+ * Errors raised by RelayService carry a `code` so callers (handlers /
+ * gateway-less HTTP wrappers) can decide how to map them to HTTP status.
+ *
+ * v1.4 trimmed the error space to just encoding failures — the service
+ * no longer broadcasts transactions, so `SUBMIT_FAILED`, `TX_REVERTED`,
+ * `SIMULATION_FAILED`, and `TIMEOUT` all went away with the operator
+ * wallet. Paymaster/Bundler errors surface out-of-band on the FE.
  */
-type RelayErrorCode = "NOT_CONFIGURED" | "ENCODE_FAILED" | "SIMULATION_FAILED" | "SUBMIT_FAILED" | "TX_REVERTED" | "TIMEOUT";
+type RelayErrorCode = "NOT_CONFIGURED" | "ENCODE_FAILED";
 declare class RelayError extends Error {
     readonly code: RelayErrorCode;
     readonly cause?: unknown;
     constructor(code: RelayErrorCode, message: string, cause?: unknown);
 }
-/**
- * Interface an operator wallet must satisfy for the RelayService. Matches
- * the subset of viem's `WalletClient` we actually call, so tests can pass
- * a minimal mock instead of a full client.
- */
-interface OperatorWalletLike {
-    writeContract: (args: {
-        address: Address;
-        abi: readonly unknown[];
-        functionName: string;
-        args: readonly unknown[];
-        account?: {
-            address: Address;
-        };
-    }) => Promise<Hex>;
-    account?: {
-        address: Address;
-    } | undefined;
-}
 
-interface RelayServiceConfig {
-    /** Address of the deployed Relay contract (chain-specific). */
-    relayAddress: Address;
-    /** Operator wallet that pays gas and receives the operator fee. */
-    operatorWallet: OperatorWalletLike;
-    /**
-     * Provider used for pre-flight simulation and receipt waiting. Optional —
-     * if omitted, the service still broadcasts but returns only `txHash`
-     * (caller is responsible for confirmation tracking).
-     */
-    provider?: PublicClient;
-    /**
-     * If a provider is supplied, wait up to this many milliseconds for a
-     * receipt before timing out. Default: 60_000 (one minute).
-     */
-    confirmationTimeoutMs?: number;
-    /**
-     * Whether to run `simulateContract` before submitting. Catches most
-     * reverts locally without wasting gas. Default: true (when provider is
-     * supplied).
-     */
-    simulateBeforeSubmit?: boolean;
-}
 /**
- * Submits `mintAndSwap` transactions to the Relay contract (legacy
- * v0.2 path) and builds unsigned UserOps for the v1.4 sponsored flow.
+ * Builds unsigned `PartialUserOperation` payloads for the v1.4 sponsored
+ * flow. The service is stateless and HTTP-client-free:
  *
- * v1.4 flow (post-Relayer-removal):
- *   - `prepareMint` — signs `MintRequest` with the issuer signer and
- *     encodes `PointToken.mint(to, amount, deadline, minterSig)` into
- *     a UserOp the user submits via EIP-7702 + Paymaster.
- *   - `prepareBurn` — mirrors on the burn side using `BurnRequest` +
- *     `PointToken.burn(from, amount, deadline, burnerSig)`.
+ *   - `prepareMint` signs a `MintRequest` EIP-712 with the caller-supplied
+ *     issuer signer wallet, then encodes `PointToken.mint(to, amount,
+ *     deadline, minterSig)` into a UserOp the frontend submits via
+ *     EIP-7702 + Paymaster.
+ *   - `prepareBurn` mirrors the above on the burn side using a
+ *     pre-signed `BurnRequest` + `PointToken.burn(from, amount,
+ *     deadline, burnerSig)`.
  *
- * Legacy v0.2 `submitMintAndSwap` still broadcasts via operator wallet
- * for the deprecated `/claim-and-swap` endpoint.
+ * There is no broadcasting, no operator wallet, no simulation — those
+ * concerns moved to the Bundler + Paymaster in v1.4.
  */
 declare class RelayService {
-    private readonly relayAddress;
-    private readonly operatorWallet;
-    private readonly provider?;
-    private readonly confirmationTimeoutMs;
-    private readonly simulateBeforeSubmit;
-    constructor(config: RelayServiceConfig);
-    /** Address the operator wallet is broadcasting from (for logging). */
-    operatorAddress(): Address | undefined;
-    /**
-     * Build calldata for the Relay `mintAndSwap` function. Kept public so
-     * callers (e.g. the MintingGateway) can log or persist the encoded call
-     * for audit before broadcasting.
-     */
-    encodeCall(params: SubmitMintAndSwapParams): Hex;
-    /**
-     * Submit a `mintAndSwap` transaction (legacy v0.2 `/claim-and-swap`).
-     *
-     * @deprecated Since 0.3.0 — replaced by `prepareMint` / `prepareBurn`
-     * in the v1.4 sponsored-UserOp flow. Kept for v0.2.x consumers;
-     * scheduled removal in 2.0.
-     */
-    submitMintAndSwap(params: SubmitMintAndSwapParams): Promise<RelayResult>;
     /**
      * Build an unsigned UserOp for Scenario 1 (Mint) — sig-gated
      * `PointToken.mint(to, amount, deadline, minterSig)`.
-     *
-     * Flow:
-     *   1. Issuer backend signs `MintRequest(to=user, amount, nonce, deadline)`
-     *      with its minter signer (HSM/KMS) → `minterSig`.
-     *   2. Encode `PointToken.mint(user, amount, deadline, minterSig)`.
-     *      On-chain, `msg.sender` must equal `to` — satisfied by EIP-7702
-     *      delegating the user EOA to BatchExecutor.
-     *   3. Optional PT fee transfer appended after mint (application-level
-     *      fee recovery since Relayer v2 no longer exists).
-     *   4. Return `PartialUserOperation` ready for Bundler gas estimate +
-     *      Paymaster sponsorship + user signature.
      */
     prepareMint(params: PrepareMintParams): Promise<PartialUserOperation>;
     /**
@@ -580,12 +489,11 @@ declare class RelayService {
      *
      * Two modes:
      *   - `mode: 'burn'` — direct `PointToken.burn(from, amount)`; only
-     *     usable if the user is a whitelisted burner. Not the typical
-     *     v1.4 path (users aren't burners); kept for admin/operator tools.
+     *     usable if the caller (via EIP-7702) is whitelisted as a burner.
+     *     Rare in v1.4; kept for admin/operator tools.
      *   - `mode: 'burnWithSig'` — `PointToken.burn(from, amount, deadline,
-     *     burnerSig)`. Issuer signs `BurnRequest` off-chain; user submits
-     *     via EIP-7702. `msg.sender == from` enforced on-chain. This is
-     *     the user-initiated redeem path in v1.4.
+     *     burnerSig)`. Caller provides a pre-signed `BurnRequest` + sig
+     *     bytes (typically from `PTRedeemHandler`).
      */
     prepareBurn(params: PrepareBurnParams): PartialUserOperation;
 }
@@ -615,7 +523,7 @@ interface PrepareMintParams {
      * at provisioning time. Typically HSM/KMS-backed in prod.
      */
     issuerSignerWallet: WalletClient;
-    /** EIP-712 domain for MintRequest (name + chainId + verifyingContract). */
+    /** EIP-712 domain for MintRequest. */
     domain: PointTokenDomainConfig;
     /** Current `mintRequestNonces[userAddress]` — caller reads from contract. */
     mintRequestNonce: bigint;
@@ -717,156 +625,6 @@ declare class FeeManager {
     estimateGasFee(): Promise<bigint>;
 }
 
-/**
- * End-user request for a full "burn points → receive USDT" flow. The
- * receiver has already signed the `ReceiverConsent` EIP-712 message on
- * the frontend; the issuer backend runs everything else.
- */
-interface MintAndCashOutRequest {
-    /** Address owning the off-chain points (== receiver in the consent). */
-    userAddress: Address;
-    /** Point token contract to mint. */
-    pointTokenAddress: Address;
-    /** Chain id the relay will submit on. */
-    chainId: number;
-    /**
-     * EIP-712 domain for `pointTokenAddress`. The gateway passes this
-     * straight through to `@pafi/core` `verifyReceiverConsent` and the
-     * issuer signer. Callers typically fetch it once via
-     * `PafiSDK.getDomain()` and cache it.
-     */
-    domain: PointTokenDomainConfig;
-    /**
-     * Receiver consent message + signature, pre-built by the frontend. The
-     * message specifies `onBehalfOf = relay contract` and
-     * `originalReceiver = userAddress`, plus the amount, nonce, deadline,
-     * and encoded extData.
-     */
-    receiverConsent: ReceiverConsent;
-    receiverSignature: Hex;
-    /**
-     * Swap path for the USDT output. Empty array = "no swap" (rare — only
-     * useful for testing). Normally a single hop pointToken → USDT.
-     */
-    swapPath: PathKey[];
-    /** Swap deadline (unix seconds). */
-    swapDeadline: bigint;
-    /**
-     * Lock TTL (ms) to apply to the off-chain balance. The gateway computes
-     * a safe default from `receiverConsent.deadline` if omitted.
-     */
-    lockDurationMs?: number;
-}
-/**
- * Result returned to the caller after a successful `processMintAndCashOut`.
- * The `lockId` is preserved so the indexer can correlate the on-chain
- * Mint event back to the ledger row (though that correlation is typically
- * done by `(userAddress, amount)` in the default `MemoryPointLedger`).
- */
-interface MintAndCashOutResponse {
-    txHash: Hex;
-    lockId: string;
-    blockNumber?: bigint;
-    gasUsed?: bigint;
-}
-/**
- * Error codes a MintingGateway can surface. Callers (API handlers) map
- * these to HTTP status codes. The `SAFE_TO_RETRY` field tells the caller
- * whether the underlying lock was released — if not, the user should
- * wait before retrying to avoid double-spend.
- */
-type MintingGatewayErrorCode = "INVALID_REQUEST" | "INVALID_CONSENT_SIGNATURE" | "CONSENT_EXPIRED" | "POLICY_REJECTED" | "INSUFFICIENT_BALANCE" | "SIGNER_FAILED" | "RELAY_SIMULATION_FAILED" | "RELAY_SUBMIT_FAILED" | "RELAY_REVERTED" | "RELAY_TIMEOUT";
-declare class MintingGatewayError extends Error {
-    readonly code: MintingGatewayErrorCode;
-    /**
-     * True if the ledger lock was released before this error was thrown,
-     * meaning the user can safely retry. False means the funds are still
-     * locked (e.g. tx may still land on-chain) and retry would double-spend.
-     */
-    readonly safeToRetry: boolean;
-    readonly cause?: unknown;
-    constructor(code: MintingGatewayErrorCode, message: string, opts: {
-        safeToRetry: boolean;
-        cause?: unknown;
-    });
-}
-
-interface MintingGatewayConfig {
-    ledger: IPointLedger;
-    policy: IPolicyEngine;
-    signer: IIssuerSigner;
-    relayService: RelayService;
-    /**
-     * Clock override for tests. Defaults to `() => Date.now()`. Used to
-     * compute safe lock TTLs and to check consent deadlines.
-     */
-    now?: () => number;
-    /**
-     * Extra buffer (ms) added on top of `(consent.deadline - now)` when the
-     * caller doesn't supply a `lockDurationMs`. Default: 60_000 (one minute
-     * — roughly 2× the Base L2 block confirmation time).
-     */
-    defaultLockBufferMs?: number;
-}
-/**
- * The MintingGateway is the central orchestrator that turns a user's
- * signed ReceiverConsent into an on-chain `mintAndSwap` tx and a
- * consistent off-chain ledger update.
- *
- * 11-step flow (per `PAFI_ISSUER_SDK_SPEC.md` §4.3):
- *
- *   1. Field validation (cheap rejects before any crypto)
- *   2. Verify ReceiverConsent signature via `@pafi/core`
- *   3. Check off-chain balance via ledger
- *   4. Check locked requests via ledger
- *   5. Run policy engine (balance + on-chain cap + issuer rules)
- *   6. Lock the requested amount in the ledger
- *   7. Sign MintRequest as issuer
- *   8. Build MintParams + SwapParams
- *   9. Submit via RelayService (encode + simulate + broadcast + wait)
- *  10. Return { txHash, lockId, receipt fields }
- *  11. On any failure, release the lock IF it's safe to retry — i.e. we
- *      know the tx cannot still land on-chain. If the tx may have made
- *      it (`TX_REVERTED` or `TIMEOUT`), we leave the lock alone and
- *      surface `safeToRetry: false` so the caller doesn't double-spend.
- *
- * The gateway deliberately does NOT deduct the balance here. Deduction
- * happens in the `PointIndexer` when the on-chain Mint event is observed,
- * which is what makes the system crash-safe: if the gateway dies between
- * broadcast and receipt, the indexer will still finalize the ledger.
- */
-declare class MintingGateway {
-    private readonly ledger;
-    private readonly policy;
-    private readonly signer;
-    private readonly relayService;
-    private readonly now;
-    private readonly defaultLockBufferMs;
-    constructor(config: MintingGatewayConfig);
-    /**
-     * @deprecated Since 0.3.0 — will be renamed to `processMint()` once
-     * the SC team finalizes Relayer v2 ABI. The new flow drops the
-     * swap steps entirely (no more single-call mint+swap); users swap
-     * separately on PAFI Web. Kept here for v0.2.x consumers. Removed in 2.0.
-     */
-    processMintAndCashOut(request: MintAndCashOutRequest): Promise<MintAndCashOutResponse>;
-    private computeLockDurationMs;
-    /**
-     * Map a RelayError to a MintingGatewayError, releasing the lock only
-     * when the tx definitely did not land. `TX_REVERTED` and `TIMEOUT`
-     * leave the lock in place because the tx may still be in the mempool
-     * or already mined — releasing would enable a double-spend on retry.
-     * Always throws.
-     */
-    private handleRelayFailure;
-    /**
-     * Release a lock, swallowing any secondary error. We never want a lock
-     * release failure to mask the original error — the lock will auto-expire
-     * via TTL anyway.
-     */
-    private releaseLockSafely;
-}
-
 /** Decoded Transfer(from=0x0 → to) event used to finalize a mint. */
 interface MintEvent {
     /** Destination address (the user who received the minted points) */
@@ -1111,6 +869,18 @@ interface ApiConfigResponse {
         mintingOracle?: Address;
         poolManager?: Address;
         usdt?: Address;
+        /**
+         * EIP-7702 delegation target — the single contract every user's
+         * EOA must delegate to before submitting sponsored UserOps. On
+         * Base mainnet this is Coinbase Smart Wallet v2.
+         */
+        batchExecutor?: Address;
+        /**
+         * Uniswap V4 hook that enforces the 10% fee on PT→USDT swaps
+         * (USDT→PT is free). FE uses this in `PoolKey.hooks` when building
+         * a swap; the pool is only discoverable when the hook matches.
+         */
+        pafiHook?: Address;
     };
     /**
      * Absolute URL that the Issuer App opens after a successful claim to
@@ -1229,7 +999,6 @@ type PoolsProvider = (request: ApiPoolsRequest) => Promise<ApiPoolsResponse>;
 
 interface IssuerApiHandlersConfig {
     authService: AuthService;
-    gateway: MintingGateway;
     ledger: IPointLedger;
     /** Used by `handleUser` to read on-chain nonces and minter status. */
     provider: PublicClient;
@@ -1260,8 +1029,7 @@ interface IssuerApiHandlersConfig {
  * Framework-agnostic HTTP handlers that match the endpoints a `PafiSDK`
  * frontend expects to call. Issuers wrap these in Express / Fastify /
  * Hono / whatever — the handlers take plain inputs and return plain
- * outputs, with `AuthError` / `MintingGatewayError` surfaced as typed
- * exceptions.
+ * outputs, with `AuthError` surfaced as typed exceptions.
  *
  * Every protected handler takes a pre-verified `userAddress` as its first
  * argument. The issuer's middleware wraps `authenticateRequest()` from
@@ -1270,7 +1038,6 @@ interface IssuerApiHandlersConfig {
  */
 declare class IssuerApiHandlers {
     private readonly authService;
-    private readonly gateway;
     private readonly ledger;
     private readonly provider;
     /**
@@ -1332,19 +1099,6 @@ declare class IssuerApiHandlers {
      * mobile apps — no app store review needed.
      */
     handleBuildConsentTypedData(userAddress: Address, request: ApiBuildConsentTypedDataRequest): Promise<ApiBuildConsentTypedDataResponse>;
-    /**
-     * `POST /claim-and-swap`
-     *
-     * @deprecated Since 0.3.0 — the single-call mint-then-swap flow is
-     * retired in v1.4. Use the new `handleClaim()` (mint only) and let
-     * the user swap separately on PAFI Web. See
-     * [V1.4_V1.5_OVERVIEW.md §4] for the new scenario model. Will be
-     * removed in 2.0.
-     *
-     * Legacy behavior: the terminal handler forwards the verified
-     * consent to the MintingGateway, which runs the 11-step flow.
-     */
-    handleClaimAndSwap(userAddress: Address, request: ApiClaimAndSwapRequest): Promise<ApiClaimAndSwapResponse>;
 }
 
 /**
@@ -1838,31 +1592,24 @@ declare class PafiBackendClient {
 }
 
 /**
- * Top-level configuration for `createIssuerService`. Everything except
- * the chain metadata, wallets, auth secret, and `signer` is optional and
- * falls back to the in-memory dev defaults — that makes the happy path
- * a single-call wire-up while still letting production issuers plug in
- * their own ledger, session store, policy engine, and KMS signer.
+ * Top-level configuration for `createIssuerService`.
  *
- * **Multi-token (0.2.0):** Pass `pointTokenAddresses: Address[]` to
+ * In v1.4 the SDK is HTTP-client-free: it signs EIP-712 messages, reads
+ * on-chain state, builds unsigned UserOperations, and maintains the
+ * off-chain ledger. It never broadcasts transactions — that's the
+ * frontend's responsibility via Bundler + Paymaster.
+ *
+ * **Multi-token (0.2.0+):** Pass `pointTokenAddresses: Address[]` to
  * support multiple PointTokens under a single issuer backend. Legacy
  * `pointTokenAddress: Address` still works for single-token deployments.
  * When both are provided, `pointTokenAddresses` takes precedence.
  */
 interface IssuerServiceConfig {
     chainId: number;
-    /**
-     * Address of the deployed PointToken. Legacy single-token shortcut;
-     * prefer `pointTokenAddresses` for multi-token issuers.
-     */
+    /** Legacy single-token shortcut; prefer `pointTokenAddresses`. */
     pointTokenAddress?: Address;
-    /**
-     * All PointToken addresses this issuer supports. Takes precedence over
-     * `pointTokenAddress`. Factory creates one `PointIndexer` per address.
-     */
+    /** All PointToken addresses this issuer supports. */
     pointTokenAddresses?: Address[];
-    /** Address of the deployed Relay contract. */
-    relayAddress: Address;
     /**
      * Full contract address bundle returned verbatim by `handleConfig` so
      * the frontend SDK can pick them up.
@@ -1873,8 +1620,6 @@ interface IssuerServiceConfig {
      * polling, and gas-price lookups. Must be pointed at the target chain.
      */
     provider: PublicClient;
-    /** Operator wallet — pays gas, receives the operator fee. */
-    operatorWallet: OperatorWalletLike;
     auth: {
         jwtSecret: string;
         /** SIWE-style login-message domain, e.g. `"app.example.com"`. */
@@ -1882,19 +1627,12 @@ interface IssuerServiceConfig {
         /** Passed straight to `jose` (`"24h"`, `"7d"`, …). Default `"24h"`. */
         jwtExpiresIn?: string;
     };
-    /**
-     * Issuer signer. No default — production issuers MUST plug in an
-     * HSM/KMS-backed implementation. For local development use
-     * `PrivateKeySigner` directly.
-     */
-    signer: IIssuerSigner;
     ledger?: IPointLedger;
     policy?: IPolicyEngine;
     sessionStore?: ISessionStore;
     /**
      * Fee management config. If omitted the `handleGasFee` endpoint will
-     * throw "not configured" at request time. Pass any subset of fields
-     * to opt in — `provider` is inherited from the outer config.
+     * throw "not configured" at request time.
      */
     fee?: Omit<FeeManagerConfig, "provider">;
     /**
@@ -1914,32 +1652,18 @@ interface IssuerServiceConfig {
          */
         autoStart?: boolean;
     };
-    relay?: {
-        simulateBeforeSubmit?: boolean;
-        confirmationTimeoutMs?: number;
-    };
-    gateway?: {
-        /** Extra lock TTL buffer beyond consent deadline. Default 60_000 ms. */
-        defaultLockBufferMs?: number;
-    };
 }
 interface IssuerService {
     authService: AuthService;
     sessionStore: ISessionStore;
     ledger: IPointLedger;
     policy: IPolicyEngine;
-    signer: IIssuerSigner;
     relayService: RelayService;
     feeManager: FeeManager | undefined;
-    gateway: MintingGateway;
-    /**
-     * All indexers keyed by PointToken address. For multi-token issuers there
-     * is one per configured token. Single-token issuers will find one entry.
-     */
+    /** All indexers keyed by PointToken address. */
     indexers: Map<Address, PointIndexer>;
     /**
-     * First indexer. Kept for backward compat with 0.1.x callers that
-     * expected `service.indexer` to be a single instance.
+     * First indexer. Kept for backward compat with 0.1.x callers.
      * @deprecated use `indexers.get(tokenAddress)` for multi-token.
      */
     indexer: PointIndexer;
@@ -1947,8 +1671,6 @@ interface IssuerService {
 }
 /**
  * Wire a fully-functional issuer service from a single config object.
- * Returns every constructed collaborator so the caller can also use the
- * indexer or relay service directly outside the HTTP layer.
  *
  * Defaults:
  *  - `ledger`          → `MemoryPointLedger`
@@ -1958,12 +1680,11 @@ interface IssuerService {
  *  - `poolsProvider`   → undefined (handlePools throws until configured)
  *  - `indexer.autoStart` → false
  *
- * Throws synchronously if any required field (`signer`, `provider`,
- * `operatorWallet`, `auth.jwtSecret`, at least one point token) is missing.
+ * Throws synchronously if any required field is missing.
  */
 declare function createIssuerService(config: IssuerServiceConfig): IssuerService;
 
 /** SDK package version — bumped on every release */
 declare const PAFI_ISSUER_SDK_VERSION = "0.1.0";
 
-export { type ApiBuildConsentTypedDataRequest, type ApiBuildConsentTypedDataResponse, type ApiClaimAndSwapRequest, type ApiClaimAndSwapResponse, type ApiConfigResponse, type ApiGasFeeResponse, type ApiLoginRequest, type ApiLoginResponse, type ApiNonceResponse, type ApiPoolsRequest, type ApiPoolsResponse, type ApiUserRequest, type ApiUserResponse, type AuthContext, AuthError, type AuthErrorCode, AuthService, type AuthServiceConfig, BalanceAggregator, type BalanceAggregatorConfig, type BurnEvent, BurnIndexer, type BurnIndexerConfig, type CombinedBalance, DefaultPolicyEngine, type DefaultPolicyEngineOptions, FeeManager, type FeeManagerConfig, type IIndexerCursorStore, type IIssuerSigner, type IPointLedger, type IPolicyEngine, type ISessionStore, InMemoryCursorStore, IssuerApiHandlers, type IssuerApiHandlersConfig, type IssuerService, type IssuerServiceConfig, type LockedMintRequest, type LoginResult, MemoryPointLedger, MemorySessionStore, type MemorySessionStoreOptions, type MintAndCashOutRequest, type MintAndCashOutResponse, type MintEvent, MintingGateway, type MintingGatewayConfig, MintingGatewayError, type MintingGatewayErrorCode, type MintingStatus, NonceManager, type OperatorWalletLike, PAFI_ISSUER_SDK_VERSION, PTRedeemError, PTRedeemHandler, type PTRedeemHandlerConfig, type PTRedeemRequest, type PTRedeemResponse, PafiBackendClient, type PafiBackendConfig, PafiBackendError, type PafiBackendErrorCode, PointIndexer, type PointIndexerConfig, type PolicyDecision, type PolicyEvalRequest, type PoolsProvider, PrivateKeySigner, type PrivateKeySignerOptions, RelayError, type RelayErrorCode, type RelayResult, RelayService, type RelayServiceConfig, type Session, type SponsorshipRequest, type SponsorshipResponse, type SubgraphNativeUsdtQuoterConfig, type SubgraphPoolsProviderConfig, type SubmitMintAndSwapParams, TopUpRedemptionError, TopUpRedemptionHandler, type TopUpRedemptionHandlerConfig, type TopUpRedemptionRequest, type TopUpRedemptionResponse, authenticateRequest, createIssuerService, createSubgraphNativeUsdtQuoter, createSubgraphPoolsProvider };
+export { type ApiBuildConsentTypedDataRequest, type ApiBuildConsentTypedDataResponse, type ApiClaimAndSwapRequest, type ApiClaimAndSwapResponse, type ApiConfigResponse, type ApiGasFeeResponse, type ApiLoginRequest, type ApiLoginResponse, type ApiNonceResponse, type ApiPoolsRequest, type ApiPoolsResponse, type ApiUserRequest, type ApiUserResponse, type AuthContext, AuthError, type AuthErrorCode, AuthService, type AuthServiceConfig, BalanceAggregator, type BalanceAggregatorConfig, type BurnEvent, BurnIndexer, type BurnIndexerConfig, type CombinedBalance, DefaultPolicyEngine, type DefaultPolicyEngineOptions, FeeManager, type FeeManagerConfig, type IIndexerCursorStore, type IIssuerSigner, type IPointLedger, type IPolicyEngine, type ISessionStore, InMemoryCursorStore, IssuerApiHandlers, type IssuerApiHandlersConfig, type IssuerService, type IssuerServiceConfig, type LockedMintRequest, type LoginResult, MemoryPointLedger, MemorySessionStore, type MemorySessionStoreOptions, type MintEvent, type MintingStatus, NonceManager, PAFI_ISSUER_SDK_VERSION, PTRedeemError, PTRedeemHandler, type PTRedeemHandlerConfig, type PTRedeemRequest, type PTRedeemResponse, PafiBackendClient, type PafiBackendConfig, PafiBackendError, type PafiBackendErrorCode, PointIndexer, type PointIndexerConfig, type PolicyDecision, type PolicyEvalRequest, type PoolsProvider, type PrepareBurnDirectParams, type PrepareBurnParams, type PrepareBurnWithSigParams, type PrepareMintParams, PrivateKeySigner, type PrivateKeySignerOptions, RelayError, type RelayErrorCode, RelayService, type Session, type SponsorshipRequest, type SponsorshipResponse, type SubgraphNativeUsdtQuoterConfig, type SubgraphPoolsProviderConfig, TopUpRedemptionError, TopUpRedemptionHandler, type TopUpRedemptionHandlerConfig, type TopUpRedemptionRequest, type TopUpRedemptionResponse, authenticateRequest, createIssuerService, createSubgraphNativeUsdtQuoter, createSubgraphPoolsProvider };