@aastar/sdk 0.20.7 → 0.20.9

package/dist/enduser.d.cts

@@ -0,0 +1,261 @@
+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 UserClientConfig extends ClientConfig {
+    accountAddress: Address;
+    sbtAddress?: Address;
+    entryPointAddress?: Address;
+    superPaymasterAddress?: Address;
+    gTokenStakingAddress?: Address;
+    registryAddress?: Address;
+    gTokenAddress?: Address;
+    bundlerClient?: any;
+}
+declare class UserClient extends BaseClient {
+    accountAddress: Address;
+    sbtAddress?: Address;
+    entryPointAddress?: Address;
+    gTokenStakingAddress?: Address;
+    registryAddress?: Address;
+    gTokenAddress?: Address;
+    bundlerClient?: any;
+    constructor(config: UserClientConfig);
+    /**
+     * Deploy a new Smart Account (Supports multiple factory types)
+     * Static helper to facilitate onboarding before instantiating the UserClient.
+     *
+     * @param client - WalletClient to sign the deployment transaction
+     * @param params - Deployment parameters
+     * @returns Object containing the deployed account address and transaction hash
+     */
+    static deployAccount(client: any, params: {
+        owner: Address;
+        salt?: bigint;
+        factoryAddress?: Address;
+        publicClient?: any;
+        accountType?: 'simple' | 'kernel' | 'safe' | string;
+        customAbi?: any;
+    }): Promise<{
+        accountAddress: Address;
+        hash: Hash;
+    }>;
+    /**
+     * Get the nonce of the account from EntryPoint (more reliable for 4337)
+     */
+    getNonce(key?: bigint): Promise<bigint>;
+    /**
+     * Get the owner of the AA account
+     */
+    getOwner(): Promise<Address>;
+    /**
+     * Execute a transaction from the AA account
+     */
+    execute(target: Address, value: bigint, data: Hex, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Execute a batch of transactions
+     */
+    executeBatch(targets: Address[], values: bigint[], datas: Hex[], options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Get user's SBT balance
+     */
+    getSBTBalance(): Promise<bigint>;
+    mintSBT(roleId: Hex, options?: TransactionOptions): Promise<Hash>;
+    transferToken(token: Address, to: Address, amount: bigint, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Get Token Balance
+     */
+    getTokenBalance(token: Address): Promise<bigint>;
+    stakeForRole(roleId: Hex, amount: bigint, options?: TransactionOptions): Promise<Hash>;
+    unstakeFromRole(roleId: Hex, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Get staked balance for a specific role
+     */
+    getStakedBalance(roleId: Hex): Promise<bigint>;
+    exitRole(roleId: Hex, options?: TransactionOptions): Promise<Hash>;
+    leaveCommunity(community: Address, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Register as EndUser (One-click: Approve + Register)
+     * Handles GToken approval to Staking contract and Role registration.
+     */
+    registerAsEndUser(communityAddress: Address, stakeAmount: bigint, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Execute a transaction with Gasless Sponsorship
+     */
+    executeGasless(params: {
+        target: Address;
+        value: bigint;
+        data: Hex;
+        paymaster: Address;
+        paymasterType: 'V4' | 'Super';
+        operator?: Address;
+        maxRate?: bigint;
+    }, options?: TransactionOptions): Promise<Hash>;
+}
+
+interface CommunityClientConfig extends ClientConfig {
+    sbtAddress?: Address;
+    factoryAddress?: Address;
+    reputationAddress?: Address;
+}
+interface CreateCommunityParams {
+    name: string;
+    tokenSymbol: string;
+    ensName?: string;
+    description?: string;
+}
+interface CommunityInfo {
+    address: Address;
+}
+/**
+ * Client for Community Managers (`ROLE_COMMUNITY`)
+ */
+declare class CommunityClient extends BaseClient {
+    sbtAddress?: Address;
+    factoryAddress?: Address;
+    reputationAddress?: Address;
+    constructor(config: CommunityClientConfig);
+    /**
+     * Create a new Community Token (xPNTs) and register it.
+     * Note: In the current architecture, creating a community often involves:
+     * 1. Registering the ROLE_COMMUNITY on Registry (if not exists) -> usually manual or self-register
+     * 2. Deploying a Token (xPNTs) via Factory
+     * 3. Linking the Token to the Community in Registry
+     */
+    createCommunityToken(params: CreateCommunityParams, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Get Community Details (Decodes Role Metadata)
+     * @param communityAddress - The address of the community manager (defaults to self)
+     */
+    getCommunityInfo(communityAddress?: Address): Promise<{
+        name: string;
+        ensName: string;
+        website: string;
+        description: string;
+        logoURI: string;
+        stakeAmount: bigint;
+    }>;
+    /**
+     * Register self as a Community Manager.
+     * This method handles all necessary steps:
+     * 1. Checks and approves GToken to GTokenStaking
+     * 2. Encodes CommunityRoleData with provided parameters
+     * 3. Calls registerRoleSelf on Registry
+     *
+     * @param params Community registration parameters
+     * @param options Transaction options
+     * @returns Transaction hash
+     */
+    registerAsCommunity(params: {
+        name: string;
+        ensName?: string;
+        website?: string;
+        description?: string;
+        logoURI?: string;
+        stakeAmount?: bigint;
+    }, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * One-click Setup: Register Community + Deploy Token
+     * Orchestrates the complete community initialization flow.
+     */
+    setupCommunity(params: {
+        name: string;
+        tokenName: string;
+        tokenSymbol: string;
+        description?: string;
+        logoURI?: string;
+        website?: string;
+        stakeAmount?: bigint;
+    }, options?: TransactionOptions): Promise<{
+        tokenAddress: Address;
+        hashes: Hash[];
+    }>;
+    /**
+     * Airdrop SBTs to users to make them members
+     */
+    airdropSBT(users: Address[], roleId: bigint, options?: TransactionOptions): Promise<Hash>;
+    setReputationRule(ruleId: bigint, ruleConfig: any, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Revoke membership (Burn SBT)
+     */
+    revokeMembership(userAddr: Address, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Transfer ownership of the Community Token
+     */
+    transferCommunityTokenOwnership(tokenAddress: Address, newOwner: Address, options?: TransactionOptions): Promise<Hash>;
+}
+
+interface GaslessConfig {
+    paymasterUrl: string;
+    policy?: 'CREDIT' | 'TOKEN' | 'SPONSORED';
+}
+interface UserLifecycleConfig extends ClientConfig {
+    accountAddress: Address;
+    registryAddress: Address;
+    sbtAddress: Address;
+    gTokenAddress: Address;
+    gTokenStakingAddress: Address;
+    entryPointAddress: Address;
+    gasless?: GaslessConfig;
+}
+interface OnboardResult {
+    success: boolean;
+    sbtId?: bigint;
+    txHash?: Hash;
+}
+interface ReputationData {
+    score: bigint;
+    level: bigint;
+    creditLimit: bigint;
+}
+/**
+ * UserLifecycle - L3 Pattern
+ *
+ * Responsibilities:
+ * 1. Managing the complete lifecycle of an End User (Onboard -> Operate -> Exit)
+ * 2. Providing a unified interface for Gasless operations
+ * 3. Abstracting underlying contract interactions via L2 Actions
+ */
+declare class UserLifecycle extends BaseClient {
+    accountAddress: Address;
+    registryAddress: Address;
+    sbtAddress: Address;
+    gTokenAddress: Address;
+    gTokenStakingAddress: Address;
+    entryPointAddress: Address;
+    gaslessConfig?: GaslessConfig;
+    config: UserLifecycleConfig;
+    constructor(config: UserLifecycleConfig);
+    /**
+     * Check if user is eligible to join a community
+     * @param community Address of the community
+     */
+    checkEligibility(community: Address): Promise<boolean>;
+    /**
+     * One-click Onboarding: Approve -> Stake -> Register -> Mint SBT
+     * @param community Address of the community to join
+     * @param stakeAmount Amount of GToken to stake (default 0.4 GT)
+     */
+    onboard(community: Address, stakeAmount?: bigint): Promise<OnboardResult>;
+    /**
+     * Enable or update Gasless configuration
+     */
+    enableGasless(config: GaslessConfig): Promise<void>;
+    /**
+     * Execute a transaction effectively using Gasless configuration if available
+     */
+    executeGaslessTx(params: {
+        target: Address;
+        value: bigint;
+        data: Hex;
+        operator?: Address;
+    }): Promise<Hash>;
+    claimSBT(roleId: Hex, options?: TransactionOptions): Promise<Hash>;
+    getMyReputation(): Promise<ReputationData>;
+    getCreditLimit(): Promise<bigint>;
+    leaveCommunity(community: Address, options?: TransactionOptions): Promise<Hash>;
+    exitRole(roleId: Hex, options?: TransactionOptions): Promise<Hash>;
+    unstakeAll(roleId: Hex, options?: TransactionOptions): Promise<Hash>;
+}
+
+export { CommunityClient, type CommunityClientConfig, type CommunityInfo, type CreateCommunityParams, type GaslessConfig, type OnboardResult, type ReputationData, UserClient, type UserClientConfig, UserLifecycle, type UserLifecycleConfig };

package/dist/identity.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var chunkJTWY2XEG_cjs = require('./chunk-JTWY2XEG.cjs');
+require('./chunk-FTJD2DWE.cjs');
+require('./chunk-S5IKOOUR.cjs');
+require('./chunk-Q7SFCCGT.cjs');
+
+
+
+Object.defineProperty(exports, "ReputationClient", {
+  enumerable: true,
+  get: function () { return chunkJTWY2XEG_cjs.ReputationClient; }
+});
+Object.defineProperty(exports, "checkMySBT", {
+  enumerable: true,
+  get: function () { return chunkJTWY2XEG_cjs.checkMySBT; }
+});
+Object.defineProperty(exports, "getMySBTId", {
+  enumerable: true,
+  get: function () { return chunkJTWY2XEG_cjs.getMySBTId; }
+});
+//# sourceMappingURL=identity.cjs.map
+//# sourceMappingURL=identity.cjs.map

package/dist/identity.cjs.map

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

package/dist/identity.d.cts

@@ -0,0 +1,81 @@
+import { Address, Hash } from 'viem';
+import { P as PublicClient, W as WalletClient } from './doc-types-471vSmPO.cjs';
+
+/**
+ * Check if user holds MySBT token (identity verification).
+ *
+ * Does NOT swallow read errors: `balanceOf` returns 0 for a non-holder, so any
+ * thrown error is an RPC/transport/contract failure — masking it as
+ * `{ hasSBT: false }` would turn a transient RPC blip into a false "no SBT" and
+ * wrongly fail eligibility checks. The error propagates so the caller can retry
+ * or surface "couldn't determine" rather than "no SBT".
+ */
+declare function checkMySBT(client: any, sbtAddress: Address, user: Address): Promise<{
+    hasSBT: boolean;
+    balance: bigint;
+}>;
+/**
+ * Fetch MySBT token ID for a specific user.
+ * MySBT exposes `getUserSBT(address) -> uint256` (alias of the `userToSBT`
+ * mapping), which returns the user's tokenId or 0 when they hold no SBT.
+ *
+ * Returns the tokenId, or `null` ONLY for the genuine "no SBT" sentinel (id == 0).
+ * Read errors are NOT swallowed (see {@link checkMySBT}): a transient RPC failure
+ * must not be reported as "no SBT" (a false negative for eligibility). The error
+ * propagates to the caller.
+ */
+declare function getMySBTId(client: any, sbtAddress: Address, user: Address): Promise<bigint | null>;
+
+declare class ReputationClient {
+    private client;
+    private reputationAddress;
+    /** @internal */
+    private walletClient?;
+    /**
+     * Initialize ReputationClient
+     * @param client The public client for queries
+     * @param reputationAddress The address of the reputation system contract
+     * @param walletClient Optional wallet client for write operations
+     */
+    constructor(client: PublicClient, reputationAddress: Address, walletClient?: WalletClient);
+    /**
+     * Compute reputation score for a user
+     */
+    computeScore(user: Address, communities: Address[], ruleIds: `0x${string}`[][], activities: bigint[][]): Promise<bigint>;
+    /**
+     * Get global reputation score for a user
+     * @param user User address
+     * @returns Reputation score
+     */
+    getGlobalReputation(user: Address): Promise<number>;
+    /**
+     * Get credit limit based on reputation
+     * @param user User address
+     * @returns Credit limit in wei (Mock logic closely tied to Reputation)
+     */
+    getCreditLimit(user: Address): Promise<bigint>;
+    /**
+     * Get reputation score breakdown
+     * @param user User address
+     * @returns Detailed reputation breakdown (Mock implementation awaiting contract V4)
+     */
+    getReputationBreakdown(user: Address): Promise<{
+        baseScore: number;
+        stakingBonus: number;
+        activityBonus: number;
+        penaltyDeduction: number;
+        total: number;
+    }>;
+    /**
+     * Submit reputation proof (off-chain data to on-chain)
+     * @param params Proof parameters
+     * @returns Transaction hash
+     */
+    submitReputationProof(params: {
+        proofType: 'github' | 'twitter' | 'on-chain-activity';
+        proofData: string;
+        signature: Hash;
+    }): Promise<Hash>;
+}
+
+export { ReputationClient, checkMySBT, getMySBTId };

package/dist/index-B6SfEQxo.d.cts

@@ -0,0 +1,47 @@
+import { Address } from 'viem';
+
+type PaymasterConfig = {
+    paymasterAddress: Address;
+    operator: Address;
+    maxRate?: bigint;
+    verificationGasLimit?: bigint;
+    postOpGasLimit?: bigint;
+};
+/**
+ * Constructs the middleware for SuperPaymaster.
+ * Returns the `paymasterAndData` hex string.
+ */
+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.
+ */
+declare function checkEligibility(client: any, paymaster: Address, user: Address, operator: Address): Promise<{
+    eligible: boolean;
+    credit?: bigint;
+    token?: Address;
+}>;
+/**
+ * Admin Client for SuperPaymaster V3
+ */
+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): 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>;
+}
+
+export { type PaymasterConfig as P, SuperPaymasterAdminClient as S, checkEligibility as c, getSuperPaymasterMiddleware as g };