@aastar/sdk 0.16.6 → 0.16.8

package/{packages/identity/src/mysbt.ts → dist/identity/src/mysbt.js}

@@ -1,15 +1,8 @@
-
-import { type Address, type PublicClient } from 'viem';
 import { MySBTABI } from '@aastar/core';
-
 /**
  * Check if user holds MySBT token (identity verification).
  */
-export async function checkMySBT(
-    client: PublicClient,
-    sbtAddress: Address,
-    user: Address
-): Promise<{ hasSBT: boolean; balance?: bigint }> {
+export async function checkMySBT(client, sbtAddress, user) {
     try {
         const balance = await client.readContract({
             address: sbtAddress,
@@ -17,32 +10,28 @@ export async function checkMySBT(
             functionName: 'balanceOf',
             args: [user]
         });
-        
-        return { 
-            hasSBT: (balance as bigint) > 0n,
-            balance: balance as bigint
+        return {
+            hasSBT: balance > 0n,
+            balance: balance
         };
-    } catch (e) {
+    }
+    catch (e) {
         console.warn('MySBT check failed:', e);
         return { hasSBT: false };
     }
 }
-
 /**
  * Fetch MySBT token ID for a specific user (if unique/SBT).
  * Note: Depends on whether the contract supports getTokenId or similar.
  */
-export async function getMySBTId(
-    client: PublicClient,
-    sbtAddress: Address,
-    user: Address
-): Promise<bigint | null> {
+export async function getMySBTId(client, sbtAddress, user) {
     try {
         // Implementation depends on the specific contract. 
         // Most SBTs use ownerOf or similar if mapping is known.
         // For standard SBT balances, we usually just need hasSBT.
         return null;
-    } catch (e) {
+    }
+    catch (e) {
         return null;
     }
 }

package/dist/paymaster/src/SuperPaymaster/index.d.ts

@@ -0,0 +1,44 @@
+import { type Address } from 'viem';
+export type PaymasterConfig = {
+    paymasterAddress: Address;
+    operator: Address;
+    maxRate?: bigint;
+    verificationGasLimit?: bigint;
+    postOpGasLimit?: bigint;
+};
+/**
+ * Constructs the middleware for SuperPaymaster.
+ * Returns the `paymasterAndData` hex string.
+ */
+export declare function getSuperPaymasterMiddleware(config: PaymasterConfig): {
+    sponsorUserOperation: (args: {
+        userOperation: any;
+    }) => Promise<{
+        paymasterAndData: `0x${string}`;
+        verificationGasLimit: bigint;
+        preVerificationGas: any;
+    }>;
+};
+/**
+ * Enhanced eligibility check for SuperPaymaster V3.
+ * Validates that user has sufficient credit with the given operator.
+ */
+export declare function checkEligibility(client: any, paymaster: Address, user: Address, operator: Address): Promise<{
+    eligible: boolean;
+    credit?: bigint;
+    token?: Address;
+}>;
+/**
+ * Admin Client for SuperPaymaster V3
+ */
+export declare class SuperPaymasterAdminClient {
+    private client;
+    private paymasterAddress;
+    constructor(client: any, paymasterAddress: Address);
+    getOperator(operator: Address): Promise<any>;
+    static configureOperator(wallet: any, paymaster: Address, token: Address, treasury: Address, exchangeRate: bigint): Promise<any>;
+    static setOperatorPaused(wallet: any, paymaster: Address, operator: Address, paused: boolean): Promise<any>;
+    static updateReputation(wallet: any, paymaster: Address, operator: Address, score: bigint): Promise<any>;
+    static setAPNTsToken(wallet: any, paymaster: Address, token: Address): Promise<any>;
+    static setXPNTsFactory(wallet: any, paymaster: Address, factory: Address): Promise<any>;
+}

package/{packages/paymaster/src/SuperPaymaster/index.ts → dist/paymaster/src/SuperPaymaster/index.js}

@@ -1,28 +1,17 @@
-import { type Address, concat, pad, toHex } from 'viem';
+import { concat, pad, toHex } from 'viem';
 import { SuperPaymasterABI as SUPERPAYMASTER_ABI } from '@aastar/core';
-
-export type PaymasterConfig = {
-    paymasterAddress: Address;
-    operator: Address;
-    maxRate?: bigint;
-    verificationGasLimit?: bigint;
-    postOpGasLimit?: bigint;
-};
-
 const DEFAULT_VERIFICATION_GAS = 160000n;
 const DEFAULT_POSTOP_GAS = 10000n;
-
 /**
  * Constructs the middleware for SuperPaymaster.
  * Returns the `paymasterAndData` hex string.
  */
-export function getSuperPaymasterMiddleware(config: PaymasterConfig) {
+export function getSuperPaymasterMiddleware(config) {
     return {
-        sponsorUserOperation: async (args: { userOperation: any }) => {
+        sponsorUserOperation: async (args) => {
             const verGas = config.verificationGasLimit ?? DEFAULT_VERIFICATION_GAS;
             const postGas = config.postOpGasLimit ?? DEFAULT_POSTOP_GAS;
             const maxRate = config.maxRate ?? 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;
-
             // V3.2.1 Layout: [Paymaster(20)] [VerGas(16)] [PostOpGas(16)] [Operator(20)] [MaxRate(32)]
             // Offset 72 starts MaxRate.
             const paymasterAndData = concat([
@@ -32,26 +21,19 @@ export function getSuperPaymasterMiddleware(config: PaymasterConfig) {
                 config.operator,
                 pad(toHex(maxRate), { size: 32 })
             ]);
-
             return {
                 paymasterAndData,
                 verificationGasLimit: verGas,
-                preVerificationGas: args.userOperation.preVerificationGas, 
+                preVerificationGas: args.userOperation.preVerificationGas,
             };
         }
     };
 }
-
 /**
  * Enhanced eligibility check for SuperPaymaster V3.
  * Validates that user has sufficient credit with the given operator.
  */
-export async function checkEligibility(
-    client: any, 
-    paymaster: Address, 
-    user: Address, 
-    operator: Address
-): Promise<{ eligible: boolean; credit?: bigint; token?: Address }> {
+export async function checkEligibility(client, paymaster, user, operator) {
     try {
         // 1. Fetch operator's configured token
         const operatorData = await client.readContract({
@@ -60,16 +42,13 @@ export async function checkEligibility(
             functionName: 'operators',
             args: [operator]
         });
-        
         // operatorData structure: [token, treasury, isConfigured, isPaused, exchangeRate, ...]
-        const token = operatorData[0] as Address;
-        const isConfigured = operatorData[2] as boolean;
-        const isPaused = operatorData[3] as boolean;
-        
+        const token = operatorData[0];
+        const isConfigured = operatorData[2];
+        const isPaused = operatorData[3];
         if (!isConfigured || isPaused) {
             return { eligible: false };
         }
-        
         // 2. Check available credit
         const credit = await client.readContract({
             address: paymaster,
@@ -77,31 +56,28 @@ export async function checkEligibility(
             functionName: 'getAvailableCredit',
             args: [user, token]
         });
-        
-        return { 
-            eligible: (credit as bigint) > 0n, 
-            credit: credit as bigint,
+        return {
+            eligible: credit > 0n,
+            credit: credit,
             token
         };
-    } catch (e) {
+    }
+    catch (e) {
         console.warn('Eligibility check failed:', e);
         return { eligible: false };
     }
 }
-
 /**
  * Admin Client for SuperPaymaster V3
  */
 export class SuperPaymasterAdminClient {
-    private client: any;
-    private paymasterAddress: Address;
-
-    constructor(client: any, paymasterAddress: Address) {
+    client;
+    paymasterAddress;
+    constructor(client, paymasterAddress) {
         this.client = client;
         this.paymasterAddress = paymasterAddress;
     }
-
-    async getOperator(operator: Address) {
+    async getOperator(operator) {
         return this.client.readContract({
             address: this.paymasterAddress,
             abi: SUPERPAYMASTER_ABI,
@@ -109,60 +85,49 @@ export class SuperPaymasterAdminClient {
             args: [operator]
         });
     }
-
-    static async configureOperator(
-        wallet: any, 
-        paymaster: Address, 
-        token: Address, 
-        treasury: Address, 
-        exchangeRate: bigint
-    ) {
+    static async configureOperator(wallet, paymaster, token, treasury, exchangeRate) {
         return wallet.writeContract({
             address: paymaster,
             abi: SUPERPAYMASTER_ABI,
             functionName: 'configureOperator',
             args: [token, treasury, exchangeRate],
             chain: wallet.chain
-        } as any);
+        });
     }
-
-    static async setOperatorPaused(wallet: any, paymaster: Address, operator: Address, paused: boolean) {
+    static async setOperatorPaused(wallet, paymaster, operator, paused) {
         return wallet.writeContract({
             address: paymaster,
             abi: SUPERPAYMASTER_ABI,
             functionName: 'setOperatorPaused',
             args: [operator, paused],
             chain: wallet.chain
-        } as any);
+        });
     }
-
-    static async updateReputation(wallet: any, paymaster: Address, operator: Address, score: bigint) {
+    static async updateReputation(wallet, paymaster, operator, score) {
         return wallet.writeContract({
             address: paymaster,
             abi: SUPERPAYMASTER_ABI,
             functionName: 'updateReputation',
             args: [operator, score],
             chain: wallet.chain
-        } as any);
+        });
     }
-
-    static async setAPNTsToken(wallet: any, paymaster: Address, token: Address) {
+    static async setAPNTsToken(wallet, paymaster, token) {
         return wallet.writeContract({
             address: paymaster,
             abi: SUPERPAYMASTER_ABI,
             functionName: 'setAPNTsToken',
             args: [token],
             chain: wallet.chain
-        } as any);
+        });
     }
-
-    static async setXPNTsFactory(wallet: any, paymaster: Address, factory: Address) {
+    static async setXPNTsFactory(wallet, paymaster, factory) {
         return wallet.writeContract({
             address: paymaster,
             abi: SUPERPAYMASTER_ABI,
             functionName: 'setXPNTsFactory',
             args: [factory],
             chain: wallet.chain
-        } as any);
+        });
     }
 }

package/dist/paymaster/src/V4/PaymasterClient.d.ts

@@ -0,0 +1,79 @@
+import { type Address, type Hex } from 'viem';
+/**
+ * PaymasterClient
+ * Focus: Integration, Funding, Interaction.
+ */
+export declare class PaymasterClient {
+    /**
+     * 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 | undefined;
+        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}`;
+}