@aastar/sdk 0.16.8 → 0.16.12

package/dist/clients/endUser.js

@@ -0,0 +1,298 @@
+import { createClient, publicActions, walletActions, parseAbi } from 'viem';
+import { registryActions, sbtActions, superPaymasterActions, paymasterActions, CORE_ADDRESSES, TOKEN_ADDRESSES, TEST_ACCOUNT_ADDRESSES, RegistryABI } from '@aastar/core';
+export function createEndUserClient({ chain, transport, account, addresses }) {
+    const client = createClient({
+        chain,
+        transport,
+        account
+    })
+        .extend(publicActions)
+        .extend(walletActions);
+    const usedAddresses = { ...CORE_ADDRESSES, ...TOKEN_ADDRESSES, ...TEST_ACCOUNT_ADDRESSES, ...addresses };
+    console.log('   SDK Debug: simpleAccountFactory from usedAddresses:', usedAddresses.simpleAccountFactory);
+    console.log('   SDK Debug: process.env.SIMPLE_ACCOUNT_FACTORY:', process.env.SIMPLE_ACCOUNT_FACTORY);
+    const actions = {
+        ...registryActions(usedAddresses.registry)(client),
+        ...sbtActions(usedAddresses.mySBT)(client),
+        ...superPaymasterActions(usedAddresses.superPaymaster)(client),
+        ...paymasterActions(usedAddresses.paymasterV4)(client)
+    };
+    return Object.assign(client, actions, {
+        async onboard({ community, roleId, roleData }) {
+            console.log('👤 Onboarding user to community...');
+            const result = await this.joinAndActivate({ community, roleId, roleData });
+            console.log(`✅ User onboarded! SBT ID: ${result.sbtId}`);
+            return { tx: result.tx, sbtId: result.sbtId };
+        },
+        async joinAndActivate({ community, roleId, roleData }) {
+            const accountToUse = account;
+            if (!accountToUse)
+                throw new Error("Account required for joinAndActivate");
+            console.log(`   SDK: Joining community ${community}...`);
+            // Registry.registerRoleSelf is now idempotent (modified contract)
+            // First call: Mints SBT + grants role
+            // Subsequent calls: Adds community membership
+            // If roleData not provided, encode EndUserRoleData structure
+            let finalData;
+            if (roleData) {
+                finalData = roleData;
+            }
+            else {
+                // Encode EndUserRoleData: (address account, address community, string avatarURI, string ensName, uint256 stakeAmount)
+                const { encodeAbiParameters } = await import('viem');
+                finalData = encodeAbiParameters([
+                    { name: 'account', type: 'address' },
+                    { name: 'community', type: 'address' },
+                    { name: 'avatarURI', type: 'string' },
+                    { name: 'ensName', type: 'string' },
+                    { name: 'stakeAmount', type: 'uint256' }
+                ], [accountToUse.address, community, '', '', 0n] // Use minimum stake (Registry will use roleConfig.minStake)
+                );
+            }
+            const regTx = await client.writeContract({
+                address: usedAddresses.registry,
+                abi: RegistryABI,
+                functionName: 'registerRoleSelf',
+                args: [roleId, finalData],
+                account: accountToUse,
+                chain
+            });
+            await client.waitForTransactionReceipt({ hash: regTx });
+            // 2. Fetch SBT ID
+            const sbtId = await actions.getUserSBT({ user: accountToUse.address });
+            console.log(`   SDK: User joined. SBT ID: ${sbtId}`);
+            // 3. Fetch Initial Credit for verification
+            let credit = 0n;
+            try {
+                const factoryAbi = parseAbi(['function communityToToken(address) view returns (address)']);
+                const tokenAddress = await client.readContract({
+                    address: usedAddresses.xPNTsFactory,
+                    abi: factoryAbi,
+                    functionName: 'communityToToken',
+                    args: [community]
+                });
+                credit = await actions.getAvailableCredit({
+                    user: client.aaAddress || accountToUse.address,
+                    token: tokenAddress
+                });
+                console.log(`   SDK: Activation complete. Current Credit: ${credit} points.`);
+            }
+            catch (error) {
+                console.log(`   SDK: Credit system not available (${error.message.split('\n')[0]}). Continuing...`);
+            }
+            return {
+                tx: regTx,
+                sbtId,
+                initialCredit: credit
+            };
+        },
+        async executeGasless({ target, data, value = 0n, operator }) {
+            const accountToUse = account;
+            if (!accountToUse)
+                throw new Error("Wallet account required for gasless execution");
+            // 1. Get AA Address (Predict if necessary)
+            const { accountAddress } = await this.createSmartAccount({ owner: accountToUse.address });
+            console.log(`   SDK: Executing gasless via AA ${accountAddress} Sponsored by ${operator}`);
+            // 2. Fetch Nonce from EntryPoint (v0.7 standard)
+            // Note: In v0.7, nonce is managed by EntryPoint, not the account itself
+            let nonce = 0n;
+            try {
+                nonce = await client.readContract({
+                    address: usedAddresses.entryPoint,
+                    abi: [{
+                            type: 'function',
+                            name: 'getNonce',
+                            inputs: [{ type: 'address', name: 'sender' }, { type: 'uint192', name: 'key' }],
+                            outputs: [{ type: 'uint256' }],
+                            stateMutability: 'view'
+                        }],
+                    functionName: 'getNonce',
+                    args: [accountAddress, 0n] // 0 = default nonce key
+                });
+            }
+            catch (e) {
+                console.warn(`   ⚠️  Failed to fetch nonce from EntryPoint, using default 0:`, e.message);
+                // For initial transactions, nonce is always 0
+                nonce = 0n;
+            }
+            // 3. Build CallData (execute(target, value, data))
+            const { encodeFunctionData, concat, pad, keccak256 } = await import('viem');
+            const executeData = encodeFunctionData({
+                abi: [{ type: 'function', name: 'execute', inputs: [{ type: 'address' }, { type: 'uint256' }, { type: 'bytes' }] }],
+                functionName: 'execute',
+                args: [target, value, data]
+            });
+            // 4. Build Gas Limits & Fees (Benchmarked for experiments)
+            const accountGasLimits = concat([
+                pad(`0x${(100000).toString(16)}`, { dir: 'left', size: 16 }), // verification
+                pad(`0x${(100000).toString(16)}`, { dir: 'left', size: 16 }) // call
+            ]);
+            const gasFees = concat([
+                pad(`0x${(2000000000).toString(16)}`, { dir: 'left', size: 16 }), // 2 gwei
+                pad(`0x${(2000000000).toString(16)}`, { dir: 'left', size: 16 }) // 2 gwei
+            ]);
+            // 5. Build PaymasterAndData (v0.7 packed format)
+            const paymasterVerificationGas = 250000n;
+            const paymasterPostOpGas = 50000n;
+            const paymasterAndData = concat([
+                usedAddresses.superPaymaster,
+                pad(`0x${paymasterVerificationGas.toString(16)}`, { dir: 'left', size: 16 }),
+                pad(`0x${paymasterPostOpGas.toString(16)}`, { dir: 'left', size: 16 }),
+                operator
+            ]);
+            // 6. Construct UserOperation v0.7
+            const userOp = {
+                sender: accountAddress,
+                nonce,
+                initCode: '0x',
+                callData: executeData,
+                accountGasLimits,
+                preVerificationGas: 50000n,
+                gasFees,
+                paymasterAndData,
+                signature: '0x'
+            };
+            // 7. Sign UserOp Hash
+            const entryPointAddress = usedAddresses.entryPoint || '0x0000000071727De22E5E9d8BAf0edAc6f37da032';
+            const userOpHash = await client.readContract({
+                address: entryPointAddress,
+                abi: [{
+                        type: 'function',
+                        name: 'getUserOpHash',
+                        inputs: [{
+                                type: 'tuple',
+                                components: [
+                                    { name: 'sender', type: 'address' },
+                                    { name: 'nonce', type: 'uint256' },
+                                    { name: 'initCode', type: 'bytes' },
+                                    { name: 'callData', type: 'bytes' },
+                                    { name: 'accountGasLimits', type: 'bytes32' },
+                                    { name: 'preVerificationGas', type: 'uint256' },
+                                    { name: 'gasFees', type: 'bytes32' },
+                                    { name: 'paymasterAndData', type: 'bytes' },
+                                    { name: 'signature', type: 'bytes' }
+                                ]
+                            }],
+                        outputs: [{ type: 'bytes32' }],
+                        stateMutability: 'view'
+                    }],
+                functionName: 'getUserOpHash',
+                args: [userOp]
+            });
+            const signature = await accountToUse.signMessage({
+                message: { raw: userOpHash }
+            });
+            userOp.signature = signature;
+            // 8. Submit via handleOps
+            console.log(`   SDK: Submitting UserOp ${userOpHash}...`);
+            const tx = await client.writeContract({
+                address: entryPointAddress,
+                abi: [{
+                        type: 'function',
+                        name: 'handleOps',
+                        inputs: [
+                            {
+                                type: 'tuple[]',
+                                components: [
+                                    { name: 'sender', type: 'address' },
+                                    { name: 'nonce', type: 'uint256' },
+                                    { name: 'initCode', type: 'bytes' },
+                                    { name: 'callData', type: 'bytes' },
+                                    { name: 'accountGasLimits', type: 'bytes32' },
+                                    { name: 'preVerificationGas', type: 'uint256' },
+                                    { name: 'gasFees', type: 'bytes32' },
+                                    { name: 'paymasterAndData', type: 'bytes' },
+                                    { name: 'signature', type: 'bytes' }
+                                ]
+                            },
+                            { name: 'beneficiary', type: 'address' }
+                        ],
+                        outputs: [],
+                        stateMutability: 'nonpayable'
+                    }],
+                functionName: 'handleOps',
+                args: [[userOp], accountToUse.address],
+                account,
+                chain
+            });
+            await client.waitForTransactionReceipt({ hash: tx });
+            return tx;
+        },
+        async checkJoinRequirements(address) {
+            const accountToUse = address || account?.address;
+            if (!accountToUse)
+                throw new Error("Account address required for requirement check");
+            const { RequirementChecker } = await import('@aastar/core');
+            const checker = new RequirementChecker(client, usedAddresses);
+            // Default requirements for standard community joining
+            return await checker.checkRequirements({
+                address: accountToUse,
+                requiredGToken: 440000000000000000n, // 0.44 GT (stake + burn)
+                requireSBT: false
+            });
+        },
+        async createSmartAccount({ owner, salt = 0n }) {
+            const { SimpleAccountFactoryABI } = await import('@aastar/core');
+            const { encodeFunctionData, concat } = await import('viem');
+            let factoryAddress = usedAddresses.simpleAccountFactory;
+            console.log(`   SDK: Using SimpleAccountFactory: ${factoryAddress} (Owner: ${owner}, Salt: ${salt})`);
+            // Fallback to official v0.7 factory if not provided
+            if (!factoryAddress || factoryAddress === '0x0000000000000000000000000000000000000000') {
+                console.warn("   ⚠️  SimpleAccountFactory not found in configuration. Using default fallback.");
+                factoryAddress = '0x9406Cc6185a346906296840746125a0E44976454';
+            }
+            const accountAddress = await client.readContract({
+                address: factoryAddress,
+                abi: SimpleAccountFactoryABI,
+                functionName: 'getAddress',
+                args: [owner, salt]
+            });
+            const createAccountData = encodeFunctionData({
+                abi: SimpleAccountFactoryABI,
+                functionName: 'createAccount',
+                args: [owner, salt]
+            });
+            const initCode = concat([factoryAddress, createAccountData]);
+            const byteCode = await client.getBytecode({ address: accountAddress });
+            const isDeployed = byteCode !== undefined && byteCode !== '0x';
+            return { accountAddress, initCode, isDeployed };
+        },
+        async deploySmartAccount({ owner, salt = 0n, fundWithETH = 0n }) {
+            const { accountAddress, isDeployed } = await this.createSmartAccount({ owner, salt });
+            const { formatEther } = await import('viem');
+            let deployHash = '0x0';
+            if (isDeployed) {
+                console.log(`   ℹ️ Account ${accountAddress} already deployed.`);
+            }
+            else {
+                const { SimpleAccountFactoryABI } = await import('@aastar/core');
+                let factoryAddress = usedAddresses.simpleAccountFactory;
+                if (!factoryAddress || factoryAddress === '0x0000000000000000000000000000000000000000') {
+                    factoryAddress = '0x9406Cc6185a346906296840746125a0E44976454';
+                }
+                console.log(`   🏭 Deploying Smart Account for ${owner}...`);
+                deployHash = await client.writeContract({
+                    address: factoryAddress,
+                    abi: SimpleAccountFactoryABI,
+                    functionName: 'createAccount',
+                    args: [owner, salt],
+                    account,
+                    chain
+                });
+                await client.waitForTransactionReceipt({ hash: deployHash });
+                console.log(`   ✅ Deployed at ${accountAddress}`);
+            }
+            if (fundWithETH > 0n) {
+                console.log(`   ⛽ Funding account with ${formatEther(fundWithETH)} ETH...`);
+                const tx = await client.sendTransaction({
+                    to: accountAddress,
+                    value: fundWithETH,
+                    account,
+                    chain
+                });
+                await client.waitForTransactionReceipt({ hash: tx });
+            }
+            return { accountAddress, deployTxHash: deployHash, isDeployed: true };
+        }
+    });
+}

package/dist/{sdk/src/clients → clients}/operator.d.ts

@@ -1,7 +1,6 @@
 import { type Client, type Transport, type Chain, type Account, type Hash, type Hex, type PublicActions, type WalletActions, type Address } from 'viem';
-import { type StakingActions, type RegistryActions, type SuperPaymasterActions, type PaymasterV4Actions, type TokenActions } from '@aastar/core';
-import { type DecodedEvent } from '../utils/eventDecoder.js';
-export type OperatorClient = Client<Transport, Chain, Account | undefined> & PublicActions<Transport, Chain, Account | undefined> & WalletActions<Chain, Account | undefined> & RegistryActions & SuperPaymasterActions & PaymasterV4Actions & StakingActions & TokenActions & {
+import { type StakingActions, type RegistryActions, type SuperPaymasterActions, type PaymasterActions } from '@aastar/core';
+export type OperatorClient = Client<Transport, Chain, Account | undefined> & PublicActions<Transport, Chain, Account | undefined> & WalletActions<Chain, Account | undefined> & RegistryActions & SuperPaymasterActions & PaymasterActions & StakingActions & {
     /**
      * High-level API: Setup operator with automatic funding and onboarding
      */
@@ -11,10 +10,7 @@ export type OperatorClient = Client<Transport, Chain, Account | undefined> & Pub
         roleId: Hex;
         roleData?: Hex;
     }) => Promise<{
-        txs: {
-            hash: Hash;
-            events: DecodedEvent[];
-        }[];
+        txs: Hash[];
     }>;
     deployPaymasterV4: (args?: {
         version?: string;
@@ -27,42 +23,24 @@ export type OperatorClient = Client<Transport, Chain, Account | undefined> & Pub
      * 3. Approve aPNTs (Deposit)
      * 4. Deposit aPNTs (SuperPaymaster)
      */
-    onboardFully: (args: {
+    onboardOperator: (args: {
         stakeAmount: bigint;
         depositAmount: bigint;
         roleId: Hex;
         roleData?: Hex;
-        gasTokens?: Address[];
-    }) => Promise<{
-        hash: Hash;
-        events: DecodedEvent[];
-    }[]>;
-    /** @deprecated Use onboardFully */
-    onboardOperator: (args: {
+    }) => Promise<Hash[]>;
+    /** @deprecated Use onboardOperator */
+    onboardToSuperPaymaster: (args: {
         stakeAmount: bigint;
         depositAmount: bigint;
         roleId: Hex;
-        roleData?: Hex;
-    }) => Promise<{
-        hash: Hash;
-        events: DecodedEvent[];
-    }[]>;
+    }) => Promise<Hash[]>;
     configureOperator: (args: {
         xPNTsToken: Address;
         treasury: Address;
         exchangeRate: bigint;
         account?: Account | Address;
     }) => Promise<Hash>;
-    /**
-     * 🧙 Wisdom: Check if operator is ready and compliant.
-     */
-    checkReadiness: () => Promise<{
-        isRegistered: boolean;
-        isConfigured: boolean;
-        collateralBalance: bigint;
-        isPaused: boolean;
-        roleStatus: boolean;
-    }>;
     getOperatorStatus: (accountAddress: Address) => Promise<{
         type: 'super' | 'v4' | null;
         superPaymaster: {
@@ -77,14 +55,6 @@ export type OperatorClient = Client<Transport, Chain, Account | undefined> & Pub
             balance: bigint;
         } | null;
     }>;
-    isOperator: (operator: Address) => Promise<boolean>;
-    getDepositDetails: () => Promise<{
-        deposit: bigint;
-    }>;
-    deposit: (args: {
-        amount: bigint;
-        account?: Account | Address;
-    }) => Promise<Hash>;
 };
 export declare function createOperatorClient({ chain, transport, account, addresses }: {
     chain: Chain;