@aastar/sdk 0.20.8 → 0.21.0

package/dist/operator.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var chunkIJN776TA_cjs = require('./chunk-IJN776TA.cjs');
+require('./chunk-CIEYY3A6.cjs');
+require('./chunk-MXJEULSE.cjs');
+require('./chunk-Q7SFCCGT.cjs');
+
+
+
+Object.defineProperty(exports, "OperatorLifecycle", {
+  enumerable: true,
+  get: function () { return chunkIJN776TA_cjs.OperatorLifecycle; }
+});
+Object.defineProperty(exports, "PaymasterOperatorClient", {
+  enumerable: true,
+  get: function () { return chunkIJN776TA_cjs.PaymasterOperatorClient; }
+});
+Object.defineProperty(exports, "ProposalState", {
+  enumerable: true,
+  get: function () { return chunkIJN776TA_cjs.ProposalState; }
+});
+Object.defineProperty(exports, "ProtocolClient", {
+  enumerable: true,
+  get: function () { return chunkIJN776TA_cjs.ProtocolClient; }
+});
+//# sourceMappingURL=operator.cjs.map
+//# sourceMappingURL=operator.cjs.map

package/dist/operator.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"operator.cjs"}

package/dist/operator.d.cts

@@ -0,0 +1,164 @@
+import { Address, Hash, Hex } from 'viem';
+import { C as ClientConfig, a as BaseClient, T as TransactionOptions } from './BaseClient-CkBhQ1ou.cjs';
+import './doc-types-471vSmPO.cjs';
+
+interface OperatorClientConfig extends ClientConfig {
+    superPaymasterAddress: Address;
+    tokenAddress?: Address;
+}
+interface SponsorshipPolicy {
+    globalLimit: bigint;
+    userLimit: bigint;
+    itemPrice: bigint;
+}
+/**
+ * Client for Paymaster Operators (ROLE_PAYMASTER_SUPER)
+ */
+declare class PaymasterOperatorClient extends BaseClient {
+    superPaymasterAddress: Address;
+    tokenAddress?: Address;
+    ethUsdPriceFeed: Address;
+    xpntsFactory: Address;
+    constructor(config: OperatorClientConfig);
+    /**
+     * Register as SuperPaymaster Operator (one-stop API).
+     * This method handles all necessary steps:
+     * 1. Checks prerequisites (must have ROLE_COMMUNITY)
+     * 2. Checks and approves GToken to GTokenStaking
+     * 3. Registers ROLE_PAYMASTER_SUPER
+     * 4. Optionally deposits collateral to SuperPaymaster
+     *
+     * @param params Registration parameters
+     * @param options Transaction options
+     * @returns Transaction hash of role registration
+     */
+    registerAsSuperPaymasterOperator(params?: {
+        stakeAmount?: bigint;
+        depositAmount?: bigint;
+    }, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Deploy a new Paymaster V4 and Register as AOA Operator (one-stop API).
+     * This method handles:
+     * 1. Checks prerequisites (ROLE_COMMUNITY)
+     * 2. Predicts new Paymaster address
+     * 3. Deploys Paymaster V4 via Factory
+     * 4. Registers ROLE_PAYMASTER_AOA with staking
+     *
+     * @param params Deployment parameters
+     * @param options Transaction options
+     * @returns Object containing new paymaster address and transaction hashes
+     */
+    deployAndRegisterPaymasterV4(params?: {
+        stakeAmount?: bigint;
+        version?: string;
+        salt?: bigint;
+        priceFeed?: Address;
+    }, options?: TransactionOptions): Promise<{
+        paymasterAddress: Address;
+        deployHash: Hash;
+        registerHash: Hash;
+    }>;
+    /**
+     * Deposit collateral (aPNTs/GToken) to SuperPaymaster.
+     * This is a helper method used by registerAsSuperPaymasterOperator.
+     */
+    depositCollateral(amount: bigint, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Configure operator parameters (Token, Treasury).
+     * Exchange rate is now read live from xPNTsToken.exchangeRate() at runtime.
+     * If parameters are undefined, existing values are preserved.
+     */
+    configureOperator(xPNTsToken?: Address, treasury?: Address, options?: TransactionOptions): Promise<Hash>;
+    withdrawCollateral(to: Address, amount: bigint, options?: TransactionOptions): Promise<Hash>;
+    isOperator(operator: Address): Promise<boolean>;
+    getOperatorDetails(operator?: Address): Promise<any>;
+    initiateExit(options?: TransactionOptions): Promise<Hash>;
+    withdrawStake(to: Address, options?: TransactionOptions): Promise<Hash>;
+    addGasToken(token: Address, price: bigint, options?: TransactionOptions): Promise<Hash>;
+    getTokenPrice(token: Address): Promise<bigint>;
+    setupPaymasterDeposit(params: {
+        paymaster: Address;
+        user: Address;
+        token: Address;
+        amount: bigint;
+    }, options?: TransactionOptions): Promise<Hash>;
+}
+
+interface ProtocolClientConfig extends ClientConfig {
+    dvtValidatorAddress: Address;
+    blsAggregatorAddress?: Address;
+    superPaymasterAddress?: Address;
+}
+declare enum ProposalState {
+    Pending = 0,
+    Active = 1,
+    Canceled = 2,
+    Defeated = 3,
+    Succeeded = 4,
+    Queued = 5,
+    Expired = 6,
+    Executed = 7
+}
+/**
+ * Client for Protocol Governors and Validators (Infrastructure)
+ */
+declare class ProtocolClient extends BaseClient {
+    dvtValidatorAddress: Address;
+    blsAggregatorAddress?: Address;
+    superPaymasterAddress?: Address;
+    constructor(config: ProtocolClientConfig);
+    /**
+     * Create a new proposal
+     */
+    createProposal(target: Address, calldata: Hex, description: string, options?: TransactionOptions): Promise<Hash>;
+    signProposal(proposalId: bigint, signature?: Hex, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Execute a proposal with collected signatures
+     */
+    executeWithProof(proposalId: bigint, signatures: Hex[], options?: TransactionOptions): Promise<Hash>;
+    registerBLSKey(publicKey: Hex, options?: TransactionOptions): Promise<Hash>;
+    setProtocolFee(bps: bigint, options?: TransactionOptions): Promise<Hash>;
+    setTreasury(treasury: Address, options?: TransactionOptions): Promise<Hash>;
+}
+
+interface OperatorStatus {
+    isConfigured: boolean;
+    isActive: boolean;
+    balance: bigint;
+}
+/**
+ * OperatorLifecycle - L3 Pattern
+ *
+ * Responsibilities:
+ * 1. Managing the complete lifecycle of a Paymaster Operator
+ * 2. Unifying setup (onboard), operation (config), and exit (withdraw)
+ */
+declare class OperatorLifecycle extends PaymasterOperatorClient {
+    constructor(config: OperatorClientConfig);
+    /**
+     * Check if the account is ready to become an operator
+     * (e.g., has GToken, has ROLE_COMMUNITY, etc.)
+     */
+    checkReadiness(): Promise<OperatorStatus>;
+    /**
+     * One-click Setup: Register + Deposit + Deploy Node
+     * Wraps existing registerAsSuperPaymasterOperator or deployAndRegisterPaymasterV4
+     */
+    setupNode(params: {
+        type: 'V4' | 'SUPER';
+        stakeAmount?: bigint;
+        depositAmount?: bigint;
+    }, options?: TransactionOptions): Promise<Hash[]>;
+    getOperatorStats(): Promise<any>;
+    /**
+     * Start the exit process: Unstake from Registry/SuperPaymaster and Unlock funds
+     */
+    initiateExit(options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Finalize exit: Withdraw all funds (Collateral + Rewards)
+     */
+    withdrawAllFunds(to?: Address, options?: TransactionOptions): Promise<Hash[]>;
+    private getTokenBalance;
+}
+
+export { type OperatorClientConfig, OperatorLifecycle, type OperatorStatus, PaymasterOperatorClient, ProposalState, ProtocolClient, type ProtocolClientConfig, type SponsorshipPolicy };

package/dist/operator.js

@@ -1,6 +1,6 @@
-export { OperatorLifecycle, PaymasterOperatorClient, ProposalState, ProtocolClient } from './chunk-BN5WY5GM.js';
-import './chunk-6QYXGMCR.js';
-import './chunk-G3UJC4EL.js';
+export { OperatorLifecycle, PaymasterOperatorClient, ProposalState, ProtocolClient } from './chunk-DQBKE4ND.js';
+import './chunk-M5WFKETT.js';
+import './chunk-UCLK6LTB.js';
 import './chunk-PZ5AY32C.js';
 //# sourceMappingURL=operator.js.map
 //# sourceMappingURL=operator.js.map

package/dist/paymaster.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+var chunkGAMSWXWI_cjs = require('./chunk-GAMSWXWI.cjs');
+require('./chunk-CIEYY3A6.cjs');
+require('./chunk-MXJEULSE.cjs');
+require('./chunk-Q7SFCCGT.cjs');
+
+
+
+Object.defineProperty(exports, "PaymasterClient", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.PaymasterClient; }
+});
+Object.defineProperty(exports, "PaymasterManager", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.PaymasterManager; }
+});
+Object.defineProperty(exports, "PaymasterOperator", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.PaymasterOperator; }
+});
+Object.defineProperty(exports, "SuperPaymasterAdminClient", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.SuperPaymasterAdminClient; }
+});
+Object.defineProperty(exports, "SuperPaymasterClient", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.SuperPaymasterClient; }
+});
+Object.defineProperty(exports, "buildPaymasterData", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.buildPaymasterData; }
+});
+Object.defineProperty(exports, "buildSuperPaymasterData", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.buildSuperPaymasterData; }
+});
+Object.defineProperty(exports, "checkEligibility", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.checkEligibility; }
+});
+Object.defineProperty(exports, "formatUserOpV07", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.formatUserOpV07; }
+});
+Object.defineProperty(exports, "getPaymasterV4Middleware", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.getPaymasterV4Middleware; }
+});
+Object.defineProperty(exports, "getSuperPaymasterMiddleware", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.getSuperPaymasterMiddleware; }
+});
+Object.defineProperty(exports, "getUserOpHashV07", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.getUserOpHashV07; }
+});
+Object.defineProperty(exports, "tuneGasLimit", {
+  enumerable: true,
+  get: function () { return chunkGAMSWXWI_cjs.tuneGasLimit; }
+});
+//# sourceMappingURL=paymaster.cjs.map
+//# sourceMappingURL=paymaster.cjs.map

package/dist/paymaster.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"paymaster.cjs"}

package/dist/paymaster.d.cts

@@ -0,0 +1,312 @@
+export { P as PaymasterConfig, S as SuperPaymasterAdminClient, c as checkEligibility, g as getSuperPaymasterMiddleware } from './index-B6SfEQxo.cjs';
+import { Address, Hex } from 'viem';
+
+type PaymasterV4MiddlewareConfig = {
+    paymasterAddress: Address;
+    gasToken: Address;
+    verificationGasLimit?: bigint;
+    postOpGasLimit?: bigint;
+};
+type GaslessReadinessReport = {
+    isReady: boolean;
+    issues: string[];
+    details: {
+        paymasterStake: bigint;
+        paymasterDeposit: bigint;
+        ethUsdPrice: bigint;
+        tokenSupported: boolean;
+        tokenPrice: bigint;
+        userTokenBalance: bigint;
+        userPaymasterDeposit: bigint;
+    };
+};
+/**
+ * Constructs the middleware for Paymaster V4.
+ * Returns the `paymasterAndData` hex string.
+ */
+declare function getPaymasterV4Middleware(config: PaymasterV4MiddlewareConfig): {
+    sponsorUserOperation: (args: {
+        userOperation: any;
+    }) => Promise<{
+        paymasterAndData: `0x${string}`;
+        verificationGasLimit: bigint;
+        preVerificationGas: any;
+    }>;
+};
+/**
+ * Build paymasterAndData for gasless UserOperation.
+ * Layout: [Paymaster(20)] [VerificationGasLimit(16)] [PostOpGasLimit(16)] [Token(20)] [ValidUntil(6)] [ValidAfter(6)]
+ */
+declare function buildPaymasterData(paymasterAddress: Address, token: Address, options?: {
+    validityWindow?: number;
+    verificationGasLimit?: bigint;
+    postOpGasLimit?: bigint;
+}): `0x${string}`;
+/**
+ * Build paymasterAndData for SuperPaymaster V3.
+ * Layout: [Paymaster(20)] [verGas(16)] [postGas(16)] [operator(20)] [maxRate(32)]
+ * Total: 104 bytes
+ *
+ * IMPORTANT: SuperPaymaster contract generates validUntil internally using:
+ *   validUntil = cachedPrice.updatedAt + priceStalenessThreshold
+ * Do NOT include validUntil/validAfter in paymasterAndData!
+ */
+declare function buildSuperPaymasterData(paymasterAddress: Address, operator: Address, options?: {
+    verificationGasLimit?: bigint;
+    postOpGasLimit?: bigint;
+    maxRate?: bigint;
+}): `0x${string}`;
+/**
+ * Helper to format UserOp for Alchemy/Standard Bundlers (v0.7 Decomposed)
+ */
+declare function formatUserOpV07(userOp: any): any;
+declare function getUserOpHashV07(userOp: any, entryPoint: Address, chainId: bigint): Hex;
+/**
+ * Tune gas limit using a dynamic nominal ceiling to satisfy Bundler efficiency (0.4)
+ * Target: Actual / Limit >= targetEfficiency
+ */
+declare function tuneGasLimit(estimate: bigint, nominalActual: bigint, targetEfficiency?: number): bigint;
+
+/**
+ * PaymasterClient
+ * Focus: Integration, Funding, Interaction.
+ */
+declare class PaymasterClient {
+    /**
+     * @private
+     * Static utility class, should not be instantiated.
+     */
+    private constructor();
+    private static makePlaceholderSignature;
+    private static estimatePreVerificationGasV07;
+    /**
+     * Get user's deposited balance on the Paymaster.
+     */
+    static getDepositedBalance(publicClient: any, address: Address, user: Address, token: Address): Promise<bigint>;
+    /**
+     * Deposit tokens to Paymaster for a user (enables gasless transactions).
+     */
+    static depositFor(wallet: any, address: Address, user: Address, token: Address, amount: bigint): Promise<any>;
+    /**
+     * Approve the Paymaster (or any spender) to spend gas tokens.
+     */
+    static approveGasToken(wallet: any, token: Address, spender: Address, amount: bigint): Promise<any>;
+    /**
+     * Estimate Gas for a UserOperation.
+     */
+    static estimateUserOperationGas(client: any, wallet: any, aaAddress: Address, entryPoint: Address, paymasterAddress: Address, token: Address, bundlerUrl: string, callData: `0x${string}`, options?: {
+        validityWindow?: number;
+        operator?: Address;
+        factory?: Address;
+        factoryData?: Hex;
+    }): Promise<{
+        preVerificationGas: bigint;
+        verificationGasLimit: bigint;
+        callGasLimit: bigint;
+        paymasterVerificationGasLimit: bigint;
+        paymasterPostOpGasLimit: bigint;
+    }>;
+    /**
+     * High-level API to submit a gasless UserOperation.
+     * Automatically handles nonce fetching, gas estimation (if not provided), signing, and submission.
+     */
+    static submitGaslessUserOperation(client: any, wallet: any, aaAddress: Address, entryPoint: Address, paymasterAddress: Address, token: Address, bundlerUrl: string, callData: `0x${string}`, options?: {
+        validityWindow?: number;
+        verificationGasLimit?: bigint;
+        callGasLimit?: bigint;
+        preVerificationGas?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        autoEstimate?: boolean;
+        operator?: Address;
+        paymasterVerificationGasLimit?: bigint;
+        paymasterPostOpGasLimit?: bigint;
+        factory?: Address;
+        factoryData?: Hex;
+    }): Promise<`0x${string}`>;
+    /**
+     * Helper to extract the actual Gas Token fee from a UserOperation receipt.
+     * Looks for the 'PostOpProcessed' event emitted by the Paymaster.
+     */
+    static getFeeFromReceipt(receipt: any, paymasterAddress: Address): {
+        tokenCost: bigint;
+        actualGasCostWei: bigint;
+    } | null;
+    /**
+     * Get the fee for a specific transaction hash.
+     * Fetches the receipt (no scanning required) and decodes the log.
+     */
+    static getTransactionFee(publicClient: any, txHash: `0x${string}`, paymasterAddress: Address): Promise<{
+        tokenCost: bigint;
+        actualGasCostWei: bigint;
+    } | null>;
+    /**
+     * Helper: Encode a standardized ERC-20 Transfer.
+     * Returns the raw function data: `transfer(to, amount)`
+     */
+    static encodeTokenTransfer(recipient: Address, amount: bigint): `0x${string}`;
+    /**
+     * Helper: Encode a SimpleAccount execution.
+     * Wraps the inner call into: `execute(target, value, data)`
+     * This is the payload signed by the user.
+     */
+    static encodeExecution(target: Address, value: bigint, data: `0x${string}`): `0x${string}`;
+    /**
+     * More robust version of waitForUserOperationReceipt.
+     * Catches timeouts and returns a cleaner result.
+     */
+    static waitForUserOperation(bundlerClient: any, hash: `0x${string}`, timeout?: number): Promise<any>;
+}
+
+/**
+ * PaymasterOperator
+ * Focus: Deployment, Configuration, Maintenance, Keeper Bots.
+ */
+declare class PaymasterOperator {
+    /**
+     * Update the cached ETH/USD price from Chainlink Oracle.
+     * Must be called if cachedPrice is 0 (uninitialized).
+     */
+    static updatePrice(wallet: any, address: Address): Promise<any>;
+    /**
+     * Set the token price (in 8 decimals, e.g., 1e8 = $1 USD).
+     */
+    static setTokenPrice(wallet: any, address: Address, token: Address, priceUSD: bigint): Promise<any>;
+    static getCachedPrice(publicClient: any, address: Address): Promise<{
+        price: bigint;
+        updatedAt: bigint;
+    }>;
+    static getTokenPrice(publicClient: any, address: Address, token: Address): Promise<bigint>;
+    static getDepositedBalance(publicClient: any, address: Address, user: Address, token: Address): Promise<bigint>;
+    static ensurePriceInitialized(wallet: any, publicClient: any, address: Address): Promise<boolean>;
+    static addStake(wallet: any, address: Address, amount: bigint, unstakeDelaySec: number): Promise<any>;
+    static addDeposit(wallet: any, address: Address, amount: bigint): Promise<any>;
+    static addGasToken(wallet: any, address: Address, token: Address): Promise<any>;
+    static removeGasToken(wallet: any, address: Address, token: Address): Promise<any>;
+    static setServiceFeeRate(wallet: any, address: Address, rate: bigint): Promise<any>;
+    static setMaxGasCostCap(wallet: any, address: Address, cap: bigint): Promise<any>;
+    static withdrawPNT(wallet: any, address: Address, to: Address, token: Address, amount: bigint): Promise<any>;
+    static checkGaslessReadiness(publicClient: any, entryPoint: Address, paymasterAddress: Address, user: Address, token: Address): Promise<GaslessReadinessReport>;
+    static prepareGaslessEnvironment(operatorWallet: any, publicClient: any, entryPoint: Address, paymasterAddress: Address, token: Address, options?: {
+        minStake?: bigint;
+        minDeposit?: bigint;
+        tokenPriceUSD?: bigint;
+    }): Promise<{
+        step: string;
+        hash?: string;
+        status: string;
+    }[]>;
+}
+
+type GaslessTransactionConfig = {
+    token: Address;
+    recipient: Address;
+    amount: bigint;
+    operator: Address;
+    paymasterAddress: Address;
+    factory?: Address;
+    factoryData?: Hex;
+};
+/**
+ * SuperPaymasterClient
+ * High-level API for SuperPaymaster operations, including dynamic gas estimation.
+ */
+declare class SuperPaymasterClient {
+    /**
+     * @private
+     * Static utility class, should not be instantiated.
+     */
+    private constructor();
+    /**
+     * Submit a gasless transaction using SuperPaymaster.
+     * Automatically handles gas estimation with a smart efficiency buffer.
+     */
+    static submitGaslessTransaction(client: any, wallet: any, aaAddress: Address, entryPoint: Address, bundlerUrl: string, config: GaslessTransactionConfig): Promise<Hex>;
+}
+
+/**
+ * Supported paymaster types.
+ * - 'v4'    → PaymasterV4 layout (84 bytes): [paymaster(20)][verGas(16)][postGas(16)][token(20)][validUntil(6)][validAfter(6)]
+ * - 'super' → SuperPaymaster layout (104 bytes): [paymaster(20)][verGas(16)][postGas(16)][operator(20)][maxRate(32)]
+ */
+type PaymasterType = 'v4' | 'super';
+/**
+ * Unified parameters for building `paymasterAndData`.
+ *
+ * The byte layout differs by paymaster type; this shape carries the union of
+ * both packers' inputs. `buildPaymasterData` validates that the fields required
+ * for the resolved type are present, and dispatches to the correct existing
+ * packer. Callers no longer need to know which format a given paymaster uses.
+ */
+interface BuildPaymasterDataParams {
+    /**
+     * Explicit paymaster type. Preferred over address-based heuristics.
+     * If omitted, the type is resolved from `paymasterAddress` against the
+     * manager's registered known-paymaster map (throws if unresolved).
+     */
+    type?: PaymasterType;
+    /** Paymaster contract address (first 20 bytes of the layout). */
+    paymasterAddress: Address;
+    /** Paymaster verification gas limit (16-byte field, both layouts). */
+    verificationGasLimit?: bigint;
+    /** Paymaster postOp gas limit (16-byte field, both layouts). */
+    postOpGasLimit?: bigint;
+    /** Gas token address. Required for type 'v4'. */
+    token?: Address;
+    /** Validity window in seconds (used to compute validUntil/validAfter). 'v4' only. */
+    validityWindow?: number;
+    /** Operator address. Required for type 'super'. */
+    operator?: Address;
+    /** Optional max rate commitment (rug-pull protection). 'super' only. */
+    maxRate?: bigint;
+}
+/**
+ * PaymasterManager — unifies the per-type `paymasterAndData` packers behind a
+ * single `buildPaymasterData` entry point that AUTO-SELECTS the correct byte
+ * format by paymaster type.
+ *
+ * Type resolution order:
+ *   1. Explicit `params.type` (preferred — no guessing).
+ *   2. Address-based lookup against the registered known-paymaster map.
+ *
+ * The underlying packers (`buildPaymasterData` / `buildSuperPaymasterData` in
+ * PaymasterUtils) remain exported and are reused verbatim here — this class
+ * does NOT reimplement byte-packing.
+ */
+declare class PaymasterManager {
+    private readonly knownPaymasters;
+    constructor(opts?: {
+        knownPaymasters?: Record<string, PaymasterType>;
+    });
+    /**
+     * Register a known paymaster address → type mapping so that callers can
+     * omit the explicit `type` and have it resolved from the address.
+     */
+    registerPaymaster(address: Address, type: PaymasterType): void;
+    /**
+     * Record an address → type mapping, throwing on a CONFLICTING re-registration.
+     * Silently overwriting a v4 address with `super` (or vice-versa) would later
+     * pack the wrong-length paymasterData for a `type`-less call, so a conflicting
+     * re-registration is treated as a programmer error. Re-registering the SAME
+     * type (including a case-variant of the address) is an idempotent no-op.
+     */
+    private setKnownPaymaster;
+    /**
+     * Resolve a paymaster's type from a registered address. Returns undefined
+     * if the address is not registered.
+     */
+    resolveType(address: Address): PaymasterType | undefined;
+    /**
+     * Build `paymasterAndData`, auto-selecting the correct byte layout for the
+     * paymaster type. Dispatches to the existing per-type packers.
+     */
+    buildPaymasterData(params: BuildPaymasterDataParams): Hex;
+    /**
+     * Static helper: build `paymasterAndData` for an explicit type without an
+     * instance. Useful when the caller already knows the type.
+     */
+    static buildPaymasterData(type: PaymasterType, params: Omit<BuildPaymasterDataParams, 'type'>): Hex;
+    private static dispatch;
+}
+
+export { type BuildPaymasterDataParams, type GaslessReadinessReport, type GaslessTransactionConfig, PaymasterClient, PaymasterManager, PaymasterOperator, type PaymasterType, type PaymasterV4MiddlewareConfig, SuperPaymasterClient, buildPaymasterData, buildSuperPaymasterData, formatUserOpV07, getPaymasterV4Middleware, getUserOpHashV07, tuneGasLimit };

package/dist/paymaster.js

@@ -1,6 +1,6 @@
-export { PaymasterClient, PaymasterManager, PaymasterOperator, SuperPaymasterAdminClient, SuperPaymasterClient, buildPaymasterData, buildSuperPaymasterData, checkEligibility, formatUserOpV07, getPaymasterV4Middleware, getSuperPaymasterMiddleware, getUserOpHashV07, tuneGasLimit } from './chunk-MVEWJIPY.js';
-import './chunk-6QYXGMCR.js';
-import './chunk-G3UJC4EL.js';
+export { PaymasterClient, PaymasterManager, PaymasterOperator, SuperPaymasterAdminClient, SuperPaymasterClient, buildPaymasterData, buildSuperPaymasterData, checkEligibility, formatUserOpV07, getPaymasterV4Middleware, getSuperPaymasterMiddleware, getUserOpHashV07, tuneGasLimit } from './chunk-RXPSL33E.js';
+import './chunk-M5WFKETT.js';
+import './chunk-UCLK6LTB.js';
 import './chunk-PZ5AY32C.js';
 //# sourceMappingURL=paymaster.js.map
 //# sourceMappingURL=paymaster.js.map