@aastar/sdk 0.22.0 → 0.23.0

package/dist/initConfig-D8jgrcDb.d.ts

@@ -0,0 +1,518 @@
+import { Hex, Address, Account, Hash, PublicClient, WalletClient } from 'viem';
+
+/**
+ * ERC-4337 v0.7 PackedUserOperation tuple, matching the `struct PackedUserOperation`
+ * input of `dryRunValidation` / `validatePaymasterUserOp` in the SuperPaymaster ABI.
+ * Field order is load-bearing: viem encodes the tuple positionally from this shape.
+ */
+type PackedUserOperation = {
+    sender: Address;
+    nonce: bigint;
+    initCode: Hex;
+    callData: Hex;
+    accountGasLimits: Hex;
+    preVerificationGas: bigint;
+    gasFees: Hex;
+    paymasterAndData: Hex;
+    signature: Hex;
+};
+/**
+ * Result of an off-chain `dryRunValidation` pre-flight check.
+ * `ok` mirrors whether the paymaster would accept the UserOp; `reasonCode` is a
+ * bytes32 machine-readable rejection code (zero when `ok` is true).
+ */
+type DryRunValidationResult = {
+    ok: boolean;
+    reasonCode: Hex;
+};
+type SlashRecord = {
+    timestamp: bigint;
+    amount: bigint;
+    reputationLoss: bigint;
+    reason: string;
+    level: number;
+};
+type OperatorConfig = {
+    aPNTsBalance: bigint;
+    isConfigured: boolean;
+    isPaused: boolean;
+    xPNTsToken: Address;
+    reputation: number;
+    minTxInterval: number;
+    treasury: Address;
+    totalSpent: bigint;
+    totalTxSponsored: bigint;
+};
+/**
+ * Runtime-resolved aPNTs token state read live from the SuperPaymaster contract.
+ *
+ * The contract exposes the currently active token via `APNTS_TOKEN()` and an
+ * upcoming (timelocked) token via `pendingAPNTsToken()` / `pendingAPNTsTokenEta()`.
+ * Consumers should prefer `active` and may surface `pending` to warn about an
+ * upcoming migration.
+ */
+type ResolvedAPNTsToken = {
+    /** Currently active aPNTs token address, read from `APNTS_TOKEN()`. */
+    active: Address;
+    /** aPNTs token queued for migration; `zeroAddress` when none is queued. */
+    pending: Address;
+    /** Unix-second ETA when the pending change becomes executable; `0n` when none is queued. */
+    pendingEta: bigint;
+    /** True only when `active` came from the explicit `fallback` option after a failed chain read. */
+    fallbackUsed: boolean;
+};
+type SuperPaymasterActions = {
+    deposit: (args: {
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    depositETH: (args: {
+        value: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    depositFor: (args: {
+        targetOperator: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    withdrawTo: (args: {
+        to: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    withdraw: (args: {
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    addStake: (args: {
+        unstakeDelaySec: number;
+        value: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    unlockStake: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    withdrawStake: (args: {
+        to: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    configureOperator: (args: {
+        xPNTsToken: Address;
+        opTreasury: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setOperatorPaused: (args: {
+        operator: Address;
+        paused: boolean;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setOperatorLimits: (args: {
+        minTxInterval: number;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    updateReputation: (args: {
+        operator: Address;
+        newScore: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    executeSlashWithBLS: (args: {
+        operator: Address;
+        level: number;
+        proof: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    slashOperator: (args: {
+        operator: Address;
+        level: number;
+        penaltyAmount: bigint;
+        reason: string;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    updateBlockedStatus: (args: {
+        operator: Address;
+        users: Address[];
+        statuses: boolean[];
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    updateSBTStatus: (args: {
+        user: Address;
+        status: boolean;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    /** Read the unrecovered debt recorded for a user after a failed burn/recordDebt. */
+    pendingDebts: (args: {
+        token: Address;
+        user: Address;
+    }) => Promise<bigint>;
+    /** Operator retries recovering up to `amount` of the user's pending debt. */
+    retryPendingDebt: (args: {
+        token: Address;
+        user: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    /** Operator force-clears the user's pending-debt entry without recording it. */
+    clearPendingDebt: (args: {
+        token: Address;
+        user: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setAPNTSPrice: (args: {
+        newPrice: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    updatePrice: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    updatePriceDVT: (args: {
+        price: bigint;
+        updatedAt: bigint;
+        proof: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setProtocolFee: (args: {
+        newFeeBPS: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setTreasury: (args: {
+        treasury: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setXPNTsFactory: (args: {
+        factory: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setAPNTsToken: (args: {
+        token: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    /** @deprecated The deployed SuperPaymaster ABI has no direct `setBLSAggregator` — the aggregator change is timelocked via {@link queueBLSAggregator} + {@link applyBLSAggregator}. Throws {@link ErrorCode.NOT_IMPLEMENTED}. */
+    setBLSAggregator: (args: {
+        aggregator: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    withdrawProtocolRevenue: (args: {
+        to: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    executeAPNTsTokenChange: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    cancelAPNTsTokenChange: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    pendingAPNTsToken: () => Promise<Address>;
+    pendingAPNTsTokenEta: () => Promise<bigint>;
+    /**
+     * Resolve the live aPNTs token address from chain instead of relying on a static constant.
+     *
+     * Reads `APNTS_TOKEN()` (active), `pendingAPNTsToken()` and `pendingAPNTsTokenEta()`
+     * in parallel and returns them as a structured result. Prefer `active` for runtime use.
+     *
+     * If `fallback` is supplied and the chain reads fail, the static `fallback` address is
+     * returned with `fallbackUsed: true` (pending fields zeroed). Without a `fallback` the
+     * underlying error is re-thrown rather than silently masked.
+     */
+    resolveAPNTsToken: (args?: {
+        fallback?: Address;
+    }) => Promise<ResolvedAPNTsToken>;
+    emergencySetPrice: (args: {
+        newPrice: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    executeEmergencyPrice: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    cancelEmergencyPrice: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    emergencyPendingPrice: () => Promise<bigint>;
+    emergencyActivatedAt: () => Promise<bigint>;
+    emergencyQueuedAt: () => Promise<bigint>;
+    EMERGENCY_TIMELOCK: () => Promise<bigint>;
+    queueBLSAggregator: (args: {
+        aggregator: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    applyBLSAggregator: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    onTransferReceived: (args: {
+        operator: Address;
+        from: Address;
+        value: bigint;
+        data: Hex;
+    }) => Promise<Hex>;
+    validatePaymasterUserOp: (args: {
+        userOp: any;
+        userOpHash: Hex;
+        maxCost: bigint;
+    }) => Promise<{
+        context: Hex;
+        validationData: bigint;
+    }>;
+    /**
+     * Off-chain pre-flight validation of a UserOp against this paymaster.
+     * Returns `{ ok, reasonCode }` so callers can detect AA34-style rejections
+     * before submitting the UserOp on-chain. View call; never mutates state.
+     */
+    dryRunValidation: (args: {
+        userOp: PackedUserOperation;
+        maxCost: bigint;
+    }) => Promise<DryRunValidationResult>;
+    operators: (args: {
+        operator: Address;
+    }) => Promise<OperatorConfig>;
+    getAvailableCredit: (args: {
+        user: Address;
+        token: Address;
+    }) => Promise<bigint>;
+    getDeposit: () => Promise<bigint>;
+    getLatestSlash: (args: {
+        operator: Address;
+    }) => Promise<SlashRecord>;
+    getSlashCount: (args: {
+        operator: Address;
+    }) => Promise<bigint>;
+    getSlashHistory: (args: {
+        operator: Address;
+    }) => Promise<SlashRecord[]>;
+    slashHistory: (args: {
+        operator: Address;
+        index: bigint;
+    }) => Promise<SlashRecord>;
+    userOpState: (args: {
+        user: Address;
+        operator: Address;
+    }) => Promise<{
+        lastTimestamp: number;
+        isBlocked: boolean;
+    }>;
+    cachedPrice: () => Promise<{
+        price: bigint;
+        updatedAt: bigint;
+        roundId: bigint;
+        decimals: number;
+    }>;
+    aPNTsPriceUSD: () => Promise<bigint>;
+    protocolFeeBPS: () => Promise<bigint>;
+    protocolRevenue: () => Promise<bigint>;
+    totalTrackedBalance: () => Promise<bigint>;
+    priceStalenessThreshold: () => Promise<bigint>;
+    sbtHolders: (args: {
+        user: Address;
+    }) => Promise<boolean>;
+    /** True when the Chainlink ETH/USD feed is considered stale by the contract. */
+    isChainlinkStale: () => Promise<boolean>;
+    /** Current pricing mode (uint8 enum on the contract). */
+    priceMode: () => Promise<number>;
+    /** Unix-second timestamp until which the cached price remains valid (uint48). */
+    priceValidUntil: () => Promise<bigint>;
+    /** Address of the BLS aggregator pending the timelock (`zeroAddress` if none queued). */
+    pendingBLSAgg: () => Promise<Address>;
+    /** Unix-second ETA at which the pending BLS aggregator change becomes executable (uint48). */
+    pendingBLSAggEta: () => Promise<bigint>;
+    APNTS_TOKEN: () => Promise<Address>;
+    REGISTRY: () => Promise<Address>;
+    BLS_AGGREGATOR: () => Promise<Address>;
+    ETH_USD_PRICE_FEED: () => Promise<Address>;
+    treasury: () => Promise<Address>;
+    xpntsFactory: () => Promise<Address>;
+    entryPoint: () => Promise<Address>;
+    /** @deprecated Removed in the v5.x contract refactor — not in the deployed SuperPaymaster ABI. Throws {@link ErrorCode.NOT_IMPLEMENTED}. */
+    MAX_PROTOCOL_FEE: () => Promise<bigint>;
+    /** @deprecated Removed from SuperPaymaster in the v5.x refactor (this bound belongs to the standalone Paymaster contract). Throws {@link ErrorCode.NOT_IMPLEMENTED}. */
+    MAX_ETH_USD_PRICE: () => Promise<bigint>;
+    /** @deprecated Removed from SuperPaymaster in the v5.x refactor (this bound belongs to the standalone Paymaster contract). Throws {@link ErrorCode.NOT_IMPLEMENTED}. */
+    MIN_ETH_USD_PRICE: () => Promise<bigint>;
+    /** @deprecated Removed in the v5.x contract refactor — not in the deployed SuperPaymaster ABI. Throws {@link ErrorCode.NOT_IMPLEMENTED}. */
+    PAYMASTER_DATA_OFFSET: () => Promise<bigint>;
+    /** @deprecated Removed in the v5.x contract refactor — not in the deployed SuperPaymaster ABI. Throws {@link ErrorCode.NOT_IMPLEMENTED}. */
+    PRICE_CACHE_DURATION: () => Promise<bigint>;
+    /** @deprecated Removed in the v5.x contract refactor — not in the deployed SuperPaymaster ABI. Throws {@link ErrorCode.NOT_IMPLEMENTED}. */
+    RATE_OFFSET: () => Promise<bigint>;
+    /** @deprecated Removed in the v5.x contract refactor — not in the deployed SuperPaymaster ABI. Throws {@link ErrorCode.NOT_IMPLEMENTED}. */
+    VALIDATION_BUFFER_BPS: () => Promise<bigint>;
+    /** @deprecated Removed in the v5.x contract refactor — not in the deployed SuperPaymaster ABI. Throws {@link ErrorCode.NOT_IMPLEMENTED}. */
+    BPS_DENOMINATOR: () => Promise<bigint>;
+    /** Duration (seconds) of the aPNTs-token-change timelock. */
+    APNTS_TOKEN_TIMELOCK: () => Promise<bigint>;
+    owner: () => Promise<Address>;
+    transferOwnership: (args: {
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    renounceOwnership: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    version: () => Promise<string>;
+};
+declare const superPaymasterActions: (address: Address) => (client: PublicClient | WalletClient) => SuperPaymasterActions;
+
+type TokenConfig = {
+    tier1Limit: bigint;
+    tier2Limit: bigint;
+    dailyLimit: bigint;
+};
+type InitConfig = {
+    guardians: readonly [Address, Address, Address];
+    guardianP256X: readonly [Hex, Hex, Hex];
+    guardianP256Y: readonly [Hex, Hex, Hex];
+    dailyLimit: bigint;
+    approvedAlgIds: readonly number[];
+    minDailyLimit: bigint;
+    initialTokens: readonly Address[];
+    initialTokenConfigs: readonly TokenConfig[];
+};
+type PendingModuleInstall = {
+    module: Address;
+    moduleTypeId: number;
+    proposedAt: number;
+    executeAfter: number;
+    initDataHash: Hex;
+};
+type AirAccountActions = {
+    owner: () => Promise<Address>;
+    guardianCount: () => Promise<number>;
+    guardians: (args: {
+        index: bigint | number;
+    }) => Promise<Address>;
+    accountId: () => Promise<string>;
+    isValidSignature: (args: {
+        hash: Hex;
+        sig: Hex;
+    }) => Promise<Hex>;
+    requiredTier: (args: {
+        txValue: bigint;
+    }) => Promise<number>;
+    supportsModule: (args: {
+        moduleTypeId: bigint;
+    }) => Promise<boolean>;
+    p256KeyX: () => Promise<Hex>;
+    p256KeyY: () => Promise<Hex>;
+    parserRegistry: () => Promise<Address>;
+    moduleManagementNonce: () => Promise<bigint>;
+    moduleInstallTimelock: () => Promise<bigint>;
+    pendingModuleInstall: () => Promise<PendingModuleInstall>;
+    setP256Key: (args: {
+        x: Hex;
+        y: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setTierLimits: (args: {
+        tier1: bigint;
+        tier2: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setValidator: (args: {
+        validator: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setParserRegistry: (args: {
+        registry: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    /**
+     * Execute calls via an installed executor module (ERC-7579 `executeFromExecutor`).
+     * NOTE: this is a state-changing tx, so it resolves to the transaction `Hash` — the
+     * on-chain `bytes[] returnData` is NOT recoverable from a write. If you need the
+     * decoded return data, `simulateContract`/`call` the same function separately.
+     */
+    executeFromExecutor: (args: {
+        mode: Hex;
+        executionCalldata: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    validateUserOp: (args: {
+        userOp: PackedUserOperation;
+        userOpHash: Hex;
+        missingAccountFunds: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    initializeAgentAccount: (args: {
+        entryPoint: Address;
+        owner: Address;
+        config: InitConfig;
+        guardAddr: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    guardAddTokenConfig: (args: {
+        token: Address;
+        config: TokenConfig;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    guardApproveAlgorithm: (args: {
+        algId: number;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    guardDecreaseDailyLimit: (args: {
+        newLimit: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    guardDecreaseTokenDailyLimit: (args: {
+        token: Address;
+        newLimit: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    guardSetStrictMode: (args: {
+        enabled: boolean;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    proposeModuleInstall: (args: {
+        moduleTypeId: bigint;
+        module: Address;
+        initData: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    executeModuleInstall: (args: {
+        moduleInitData: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    cancelModuleInstall: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setModuleInstallTimelock: (args: {
+        newTimelock: bigint;
+        guardianSigs: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+};
+declare const airAccountActions: (address: Address) => (client: PublicClient | WalletClient) => AirAccountActions;
+
+/** One guardian slot for {@link buildInitConfig}: supply EXACTLY one of `ecdsa` or `p256`. */
+interface GuardianSpec {
+    /** An ECDSA (EOA / Safe) guardian address. Mutually exclusive with `p256`. */
+    ecdsa?: Address;
+    /** A P-256 (WebAuthn passkey) guardian public key (x, y, each bytes32). Mutually exclusive with `ecdsa`. */
+    p256?: {
+        x: Hex;
+        y: Hex;
+    };
+}
+/** Parameters for {@link buildInitConfig}. */
+interface BuildInitConfigParams {
+    /** Up to 3 guardian slots (ECDSA and/or P-256, freely mixed). Empty/omitted ⇒ no guardians. */
+    guardians?: readonly GuardianSpec[];
+    /** Per-account daily spend limit (wei). Must be > 0 to enable the on-chain GUARD. */
+    dailyLimit: bigint;
+    /**
+     * Validator algorithm ids approved at init (0x02 = ECDSA, 0x03 = P-256/passkey). If omitted,
+     * deriving from the owner/guardian mix is NOT possible (owner alg is separate), so it defaults
+     * to `[0x02]` (ECDSA) plus `0x03` (P-256) when any P-256 guardian is present — i.e. `[0x02, 0x03]`.
+     */
+    approvedAlgIds?: readonly number[];
+    /** Floor the daily limit can be decreased to via the guard. Defaults to 0. */
+    minDailyLimit?: bigint;
+    /** ERC-20 tokens to pre-register with the guard. Defaults to none. */
+    initialTokens?: readonly Address[];
+    /** Per-token tier configs, index-aligned with `initialTokens`. Defaults to none. */
+    initialTokenConfigs?: readonly TokenConfig[];
+}
+/**
+ * Build a v0.20.0 `InitConfig` with mixed ECDSA + P-256 guardians.
+ * @throws {AAStarError} if any slot is ambiguous, the sentinel is misused, or > 3 guardians are given.
+ */
+declare function buildInitConfig(params: BuildInitConfigParams): InitConfig;
+
+export { type AirAccountActions as A, type BuildInitConfigParams as B, type DryRunValidationResult as D, type GuardianSpec as G, type InitConfig as I, type OperatorConfig as O, type PendingModuleInstall as P, type ResolvedAPNTsToken as R, type SuperPaymasterActions as S, type TokenConfig as T, type SlashRecord as a, airAccountActions as b, buildInitConfig as c, type PackedUserOperation as d, superPaymasterActions as s };